diff --git a/.gitmodules b/.gitmodules
index 630b550732b..ffd25d161ed 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -7,6 +7,3 @@ url=https://github.com/MrHelmut/NVorbis.git
 [submodule "ThirdParty/SDL_GameControllerDB"]
 	path = ThirdParty/SDL_GameControllerDB
 	url = https://github.com/gabomdq/SDL_GameControllerDB.git
-[submodule "MonoGame.Framework"]
-	path = MonoGame.Framework
-	url = https://github.com/wihu/MonoGame.Framework.git
diff --git a/MonoGame.Framework b/MonoGame.Framework
deleted file mode 160000
index 73e51e2de7a..00000000000
--- a/MonoGame.Framework
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 73e51e2de7a8211bf10e86f3df3c14d826873884
diff --git a/MonoGame.Framework/Android/AndroidCompatibility.cs b/MonoGame.Framework/Android/AndroidCompatibility.cs
new file mode 100644
index 00000000000..28d9a537ca1
--- /dev/null
+++ b/MonoGame.Framework/Android/AndroidCompatibility.cs
@@ -0,0 +1,110 @@
+using System;
+using System.Linq;
+using Android.App;
+using Android.Content.Res;
+using Android.OS;
+using Android.Views;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Properties that change from how XNA works by default
+    /// </summary>
+    public static class AndroidCompatibility
+    {
+		/// <summary>
+		/// Because the Kindle Fire devices default orientation is fliped by 180 degrees from all the other android devices
+		/// on the market we need to do some special processing to make sure that LandscapeLeft is the correct way round.
+		/// This list contains all the Build.Model strings of the effected devices, it should be added to if and when
+		/// more devices exhibit the same issues.
+		/// </summary>
+        private static readonly string[] Kindles = new[] { "KFTT", "KFJWI", "KFJWA", "KFSOWI", "KFTHWA", "KFTHWI", "KFAPWA", "KFAPWI" };
+
+        public static bool FlipLandscape { get; private set; }
+        public static Lazy<Orientation> NaturalOrientation { get; private set; }
+
+        static AndroidCompatibility()
+        {
+			FlipLandscape = Kindles.Contains(Build.Model);
+            NaturalOrientation = new Lazy<Orientation>(GetDeviceNaturalOrientation);
+        }
+
+        private static Orientation GetDeviceNaturalOrientation()
+        {
+            var orientation = Game.Activity.Resources.Configuration.Orientation;
+            SurfaceOrientation rotation = Game.Activity.WindowManager.DefaultDisplay.Rotation;
+
+            if (((rotation == SurfaceOrientation.Rotation0 || rotation == SurfaceOrientation.Rotation180) &&
+                orientation == Orientation.Landscape)
+                || ((rotation == SurfaceOrientation.Rotation90 || rotation == SurfaceOrientation.Rotation270) &&
+                orientation == Orientation.Portrait))
+            {
+                return Orientation.Landscape;
+            }
+            else
+            {
+                return Orientation.Portrait;
+            }
+        }
+
+        internal static DisplayOrientation GetAbsoluteOrientation(int orientation)
+        {
+            // Orientation is reported by the device in degrees compared to the natural orientation
+            // Some tablets have a natural landscape orientation, which we need to account for
+            if (NaturalOrientation.Value == Orientation.Landscape)
+                orientation += 270;
+
+            // Round orientation into one of 4 positions, either 0, 90, 180, 270. 
+            int ort = ((orientation + 45) / 90 * 90) % 360;
+
+            // Surprisingly 90 degree is landscape right, except on Kindle devices
+            var disporientation = DisplayOrientation.Unknown;
+            switch (ort)
+            {
+                case 90: disporientation = FlipLandscape ? DisplayOrientation.LandscapeLeft : DisplayOrientation.LandscapeRight;
+                    break;
+                case 270: disporientation = FlipLandscape ? DisplayOrientation.LandscapeRight : DisplayOrientation.LandscapeLeft;
+                    break;
+                case 0: disporientation = DisplayOrientation.Portrait;
+                    break;
+                case 180: disporientation = DisplayOrientation.PortraitDown;
+                    break;
+                default:
+                    disporientation = DisplayOrientation.LandscapeLeft;
+                    break;
+            }
+
+            return disporientation;
+        }
+
+        /// <summary>
+        /// Get the absolute orientation of the device, accounting for platform differences.
+        /// </summary>
+        /// <returns></returns>
+        public static DisplayOrientation GetAbsoluteOrientation()
+        {
+            var orientation = Game.Activity.WindowManager.DefaultDisplay.Rotation;
+
+            // Landscape degrees (provided by the OrientationListener) are swapped by default
+            // Since we use the code used by OrientationListener, we have to swap manually
+            int degrees;
+            switch (orientation)
+            {
+                case SurfaceOrientation.Rotation90:
+                    degrees = 270;
+                    break;
+                case SurfaceOrientation.Rotation180:
+                    degrees = 180;
+                    break;
+                case SurfaceOrientation.Rotation270:
+                    degrees = 90;
+                    break;
+                default:
+                    degrees = 0;
+                    break;
+            }
+
+            return GetAbsoluteOrientation(degrees);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Android/AndroidGameActivity.cs b/MonoGame.Framework/Android/AndroidGameActivity.cs
new file mode 100644
index 00000000000..8a13e04c44f
--- /dev/null
+++ b/MonoGame.Framework/Android/AndroidGameActivity.cs
@@ -0,0 +1,110 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Android.App;
+using Android.Content;
+using Android.OS;
+using Android.Views;
+
+namespace Microsoft.Xna.Framework
+{
+	[CLSCompliant(false)]
+    public class AndroidGameActivity : Activity
+    {
+        internal Game Game { private get; set; }
+
+        private ScreenReceiver screenReceiver;
+        private OrientationListener _orientationListener;
+
+        public bool AutoPauseAndResumeMediaPlayer = true;
+        public bool RenderOnUIThread = true; 
+
+		/// <summary>
+		/// OnCreate called when the activity is launched from cold or after the app
+		/// has been killed due to a higher priority app needing the memory
+		/// </summary>
+		/// <param name='savedInstanceState'>
+		/// Saved instance state.
+		/// </param>
+		protected override void OnCreate (Bundle savedInstanceState)
+		{
+            RequestWindowFeature(WindowFeatures.NoTitle);
+            base.OnCreate(savedInstanceState);
+
+			IntentFilter filter = new IntentFilter();
+		    filter.AddAction(Intent.ActionScreenOff);
+		    filter.AddAction(Intent.ActionScreenOn);
+		    filter.AddAction(Intent.ActionUserPresent);
+		    
+		    screenReceiver = new ScreenReceiver();
+		    RegisterReceiver(screenReceiver, filter);
+
+            _orientationListener = new OrientationListener(this);
+
+			Game.Activity = this;
+		}
+
+        public static event EventHandler Paused;
+
+		public override void OnConfigurationChanged (Android.Content.Res.Configuration newConfig)
+		{
+			// we need to refresh the viewport here.
+			base.OnConfigurationChanged (newConfig);
+		}
+
+        protected override void OnPause()
+        {
+            base.OnPause();
+            EventHelpers.Raise(this, Paused, EventArgs.Empty);
+
+            if (_orientationListener.CanDetectOrientation())
+                _orientationListener.Disable();
+        }
+
+        public static event EventHandler Resumed;
+        protected override void OnResume()
+        {
+            base.OnResume();
+            EventHelpers.Raise(this, Resumed, EventArgs.Empty);
+
+            if (Game != null)
+            {
+                var deviceManager = (IGraphicsDeviceManager)Game.Services.GetService(typeof(IGraphicsDeviceManager));
+                if (deviceManager == null)
+                    return;
+                ((GraphicsDeviceManager)deviceManager).ForceSetFullScreen();
+                ((AndroidGameWindow)Game.Window).GameView.RequestFocus();
+                if (_orientationListener.CanDetectOrientation())
+                    _orientationListener.Enable();
+            }
+        }
+
+		protected override void OnDestroy ()
+		{
+            UnregisterReceiver(screenReceiver);
+            ScreenReceiver.ScreenLocked = false;
+            _orientationListener = null;
+            if (Game != null)
+                Game.Dispose();
+            Game = null;
+			base.OnDestroy ();
+		}
+    }
+
+	[CLSCompliant(false)]
+	public static class ActivityExtensions
+    {
+        public static ActivityAttribute GetActivityAttribute(this AndroidGameActivity obj)
+        {			
+            var attr = obj.GetType().GetCustomAttributes(typeof(ActivityAttribute), true);
+			if (attr != null)
+			{
+            	return ((ActivityAttribute)attr[0]);
+			}
+			return null;
+        }
+    }
+
+}
diff --git a/MonoGame.Framework/Android/AndroidGamePlatform.cs b/MonoGame.Framework/Android/AndroidGamePlatform.cs
new file mode 100644
index 00000000000..2f078154cf0
--- /dev/null
+++ b/MonoGame.Framework/Android/AndroidGamePlatform.cs
@@ -0,0 +1,175 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Android.Views;
+using Microsoft.Xna.Framework.Audio;
+using Microsoft.Xna.Framework.Media;
+
+namespace Microsoft.Xna.Framework
+{
+    class AndroidGamePlatform : GamePlatform
+    {
+        public AndroidGamePlatform(Game game)
+            : base(game)
+        {
+            System.Diagnostics.Debug.Assert(Game.Activity != null, "Must set Game.Activity before creating the Game instance");
+            Game.Activity.Game = Game;
+            AndroidGameActivity.Paused += Activity_Paused;
+            AndroidGameActivity.Resumed += Activity_Resumed;
+
+            _gameWindow = new AndroidGameWindow(Game.Activity, game);
+            Window = _gameWindow;
+
+            MediaLibrary.Context = Game.Activity;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                AndroidGameActivity.Paused -= Activity_Paused;
+                AndroidGameActivity.Resumed -= Activity_Resumed;
+            }
+            base.Dispose(disposing);
+        }
+
+        private bool _initialized;
+        public static bool IsPlayingVdeo { get; set; }
+        private AndroidGameWindow _gameWindow;
+
+        public override void Exit()
+        {
+            Game.Activity.MoveTaskToBack(true);
+        }
+
+        public override void RunLoop()
+        {
+            throw new NotSupportedException("The Android platform does not support synchronous run loops");
+        }
+
+        public override void StartRunLoop()
+        {
+            _gameWindow.GameView.Resume();
+        }
+
+        public override bool BeforeUpdate(GameTime gameTime)
+        {
+            if (!_initialized)
+            {
+                Game.DoInitialize();
+                _initialized = true;
+            }
+
+            return true;
+        }
+
+        public override bool BeforeDraw(GameTime gameTime)
+        {
+            PrimaryThreadLoader.DoLoads();
+            return !IsPlayingVdeo;
+        }
+
+        public override void BeforeInitialize()
+        {
+            var currentOrientation = AndroidCompatibility.GetAbsoluteOrientation();
+
+            switch (Game.Activity.Resources.Configuration.Orientation)
+            {
+                case Android.Content.Res.Orientation.Portrait:
+                    this._gameWindow.SetOrientation(currentOrientation == DisplayOrientation.PortraitDown ? DisplayOrientation.PortraitDown : DisplayOrientation.Portrait, false);
+                    break;
+                default:
+                    this._gameWindow.SetOrientation(currentOrientation == DisplayOrientation.LandscapeRight ? DisplayOrientation.LandscapeRight : DisplayOrientation.LandscapeLeft, false);
+                    break;
+            }
+            base.BeforeInitialize();
+            _gameWindow.GameView.TouchEnabled = true;
+        }
+
+        public override bool BeforeRun()
+        {
+
+            // Run it as fast as we can to allow for more response on threaded GPU resource creation
+            _gameWindow.GameView.Run();
+
+            return false;
+        }
+
+        public override void EnterFullScreen()
+        {
+        }
+
+        public override void ExitFullScreen()
+        {
+        }
+
+        public override void BeginScreenDeviceChange(bool willBeFullScreen)
+        {
+        }
+
+        public override void EndScreenDeviceChange(string screenDeviceName, int clientWidth, int clientHeight)
+        {
+            // Force the Viewport to be correctly set
+            Game.graphicsDeviceManager.ResetClientBounds();
+        }
+
+        // EnterForeground
+        void Activity_Resumed(object sender, EventArgs e)
+        {
+            if (!IsActive)
+            {
+                IsActive = true;
+                _gameWindow.GameView.Resume();
+                if (_MediaPlayer_PrevState == MediaState.Playing && Game.Activity.AutoPauseAndResumeMediaPlayer)
+                    MediaPlayer.Resume();
+                if (!_gameWindow.GameView.IsFocused)
+                    _gameWindow.GameView.RequestFocus();
+            }
+        }
+
+        MediaState _MediaPlayer_PrevState = MediaState.Stopped;
+        // EnterBackground
+        void Activity_Paused(object sender, EventArgs e)
+        {
+            if (IsActive)
+            {
+                IsActive = false;
+                _MediaPlayer_PrevState = MediaPlayer.State;
+                _gameWindow.GameView.Pause();
+                _gameWindow.GameView.ClearFocus();
+                if (Game.Activity.AutoPauseAndResumeMediaPlayer)
+                    MediaPlayer.Pause();
+            }
+        }
+
+        public override GameRunBehavior DefaultRunBehavior
+        {
+            get { return GameRunBehavior.Asynchronous; }
+        }
+
+        public override void Log(string Message)
+        {
+#if LOGGING
+            Android.Util.Log.Debug("MonoGameDebug", Message);
+#endif
+        }
+
+        public override void Present()
+        {
+            try
+            {
+                var device = Game.GraphicsDevice;
+                if (device != null)
+                    device.Present();
+
+                _gameWindow.GameView.SwapBuffers();
+            }
+            catch (Exception ex)
+            {
+                Android.Util.Log.Error("Error in swap buffers", ex.ToString());
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Android/AndroidGameWindow.cs b/MonoGame.Framework/Android/AndroidGameWindow.cs
new file mode 100644
index 00000000000..751ffcf73c4
--- /dev/null
+++ b/MonoGame.Framework/Android/AndroidGameWindow.cs
@@ -0,0 +1,333 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Android.Content;
+using Android.Content.PM;
+using Android.OS;
+using Android.Views;
+using Microsoft.Xna.Framework.Input.Touch;
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework
+{
+    [CLSCompliant(false)]
+    public class AndroidGameWindow : GameWindow, IDisposable
+    {
+        internal MonoGameAndroidGameView GameView { get; private set; }
+        internal IResumeManager Resumer;
+
+        private readonly Game _game;
+        private Rectangle _clientBounds;
+        private DisplayOrientation _supportedOrientations = DisplayOrientation.Default;
+        private DisplayOrientation _currentOrientation;
+
+        public override IntPtr Handle { get { return IntPtr.Zero; } }
+
+
+        public void SetResumer(IResumeManager resumer)
+        {
+            Resumer = resumer;
+        }
+
+        public AndroidGameWindow(AndroidGameActivity activity, Game game)
+        {
+            _game = game;
+
+            Point size;
+            if (Build.VERSION.SdkInt < BuildVersionCodes.JellyBean)
+            {
+                size.X = activity.Resources.DisplayMetrics.WidthPixels;
+                size.Y = activity.Resources.DisplayMetrics.HeightPixels;
+            }
+            else
+            {
+                Android.Graphics.Point p = new Android.Graphics.Point();
+                activity.WindowManager.DefaultDisplay.GetRealSize(p);
+                size.X = p.X;
+                size.Y = p.Y;
+            }
+
+            Initialize(activity, size);
+
+            game.Services.AddService(typeof(View), GameView);
+        }
+
+        private void Initialize(Context context, Point size)
+        {
+            _clientBounds = new Rectangle(0, 0, size.X, size.Y);
+            
+            GameView = new MonoGameAndroidGameView(context, this, _game);
+            GameView.RenderOnUIThread = Game.Activity.RenderOnUIThread;
+            GameView.RenderFrame += OnRenderFrame;
+            GameView.UpdateFrame += OnUpdateFrame;
+
+            GameView.RequestFocus();
+            GameView.FocusableInTouchMode = true;
+        }
+
+        #region AndroidGameView Methods
+
+        private void OnRenderFrame(object sender, MonoGameAndroidGameView.FrameEventArgs frameEventArgs)
+        {
+            GameView.MakeCurrent();
+
+            Threading.Run();
+        }
+
+        private void OnUpdateFrame(object sender, MonoGameAndroidGameView.FrameEventArgs frameEventArgs)
+        {
+            GameView.MakeCurrent();
+
+            Threading.Run();
+
+            if (_game != null)
+            {
+                if (!GameView.IsResuming && _game.Platform.IsActive && !ScreenReceiver.ScreenLocked) //Only call draw if an update has occured
+                {
+                    _game.Tick();
+                }
+                else if (_game.GraphicsDevice != null)
+                {
+                    _game.GraphicsDevice.Clear(Color.Black);
+                    if (GameView.IsResuming && Resumer != null)
+                    {
+                        Resumer.Draw();
+                    }
+                    _game.Platform.Present();
+                }
+            }
+        }
+
+        #endregion
+
+
+        protected internal override void SetSupportedOrientations(DisplayOrientation orientations)
+        {
+            _supportedOrientations = orientations;
+        }
+
+        /// <summary>
+        /// In Xna, setting SupportedOrientations = DisplayOrientation.Default (which is the default value)
+        /// has the effect of setting SupportedOrientations to landscape only or portrait only, based on the
+        /// aspect ratio of PreferredBackBufferWidth / PreferredBackBufferHeight
+        /// </summary>
+        /// <returns></returns>
+        internal DisplayOrientation GetEffectiveSupportedOrientations()
+        {
+            if (_supportedOrientations == DisplayOrientation.Default)
+            {
+                var deviceManager = (_game.Services.GetService(typeof(IGraphicsDeviceManager)) as GraphicsDeviceManager);
+                if (deviceManager == null)
+                    return DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight;
+
+                if (deviceManager.PreferredBackBufferWidth > deviceManager.PreferredBackBufferHeight)
+                {
+                    return DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight;
+                }
+                else
+                {
+                    return DisplayOrientation.Portrait | DisplayOrientation.PortraitDown;
+                }
+            }
+            else
+            {
+                return _supportedOrientations;
+            }
+        }
+
+        /// <summary>
+        /// Updates the screen orientation. Filters out requests for unsupported orientations.
+        /// </summary>
+        internal void SetOrientation(DisplayOrientation newOrientation, bool applyGraphicsChanges)
+        {
+            DisplayOrientation supported = GetEffectiveSupportedOrientations();
+
+            // If the new orientation is not supported, force a supported orientation
+            if ((supported & newOrientation) == 0)
+            {
+                if ((supported & DisplayOrientation.LandscapeLeft) != 0)
+                    newOrientation = DisplayOrientation.LandscapeLeft;
+                else if ((supported & DisplayOrientation.LandscapeRight) != 0)
+                    newOrientation = DisplayOrientation.LandscapeRight;
+                else if ((supported & DisplayOrientation.Portrait) != 0)
+                    newOrientation = DisplayOrientation.Portrait;
+                else if ((supported & DisplayOrientation.PortraitDown) != 0)
+                    newOrientation = DisplayOrientation.PortraitDown;
+            }
+
+            DisplayOrientation oldOrientation = CurrentOrientation;
+
+            SetDisplayOrientation(newOrientation);
+            TouchPanel.DisplayOrientation = newOrientation;
+
+            if (applyGraphicsChanges && oldOrientation != CurrentOrientation && _game.graphicsDeviceManager != null)
+                _game.graphicsDeviceManager.ApplyChanges();
+        }
+
+        public override string ScreenDeviceName
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+
+        public override Rectangle ClientBounds
+        {
+            get
+            {
+                return _clientBounds;
+            }
+        }
+
+        internal void ChangeClientBounds(Rectangle bounds)
+        {
+            if (bounds != _clientBounds)
+            {
+                _clientBounds = bounds;
+                OnClientSizeChanged();
+            }
+        }
+
+        public override bool AllowUserResizing
+        {
+            get
+            {
+                return false;
+            }
+            set
+            {
+                // Do nothing; Ignore rather than raising an exception
+            }
+        }
+
+        // A copy of ScreenOrientation from Android 2.3
+        // This allows us to continue to support 2.2 whilst
+        // utilising the 2.3 improved orientation support.
+        enum ScreenOrientationAll
+        {
+            Unspecified = -1,
+            Landscape = 0,
+            Portrait = 1,
+            User = 2,
+            Behind = 3,
+            Sensor = 4,
+            Nosensor = 5,
+            SensorLandscape = 6,
+            SensorPortrait = 7,
+            ReverseLandscape = 8,
+            ReversePortrait = 9,
+            FullSensor = 10,
+        }
+
+        public override DisplayOrientation CurrentOrientation
+        {
+            get
+            {
+                return _currentOrientation;
+            }
+        }
+
+        
+        private void SetDisplayOrientation(DisplayOrientation value)
+        {
+            if (value != _currentOrientation)
+            {
+                DisplayOrientation supported = GetEffectiveSupportedOrientations();
+                ScreenOrientation requestedOrientation = ScreenOrientation.Unspecified;
+                bool wasPortrait = _currentOrientation == DisplayOrientation.Portrait || _currentOrientation == DisplayOrientation.PortraitDown;
+                bool requestPortrait = false;
+
+                bool didOrientationChange = false;
+                // Android 2.3 and above support reverse orientations
+                int sdkVer = (int)Android.OS.Build.VERSION.SdkInt;
+                if (sdkVer >= 10)
+                {
+                    // Check if the requested orientation is supported. Default means all are supported.
+                    if ((supported & value) != 0)
+                    {
+                        didOrientationChange = true;
+                        _currentOrientation = value;
+                        switch (value)
+                        {
+                            case DisplayOrientation.LandscapeLeft:
+                                requestedOrientation = (ScreenOrientation)ScreenOrientationAll.Landscape;
+                                requestPortrait = false;
+                                break;
+                            case DisplayOrientation.LandscapeRight:
+                                requestedOrientation = (ScreenOrientation)ScreenOrientationAll.ReverseLandscape;
+                                requestPortrait = false;
+                                break;
+                            case DisplayOrientation.Portrait:
+                                requestedOrientation = (ScreenOrientation)ScreenOrientationAll.Portrait;
+                                requestPortrait = true;
+                                break;
+                            case DisplayOrientation.PortraitDown:
+                                requestedOrientation = (ScreenOrientation)ScreenOrientationAll.ReversePortrait;
+                                requestPortrait = true;
+                                break;
+                        }
+                    }
+                }
+                else
+                {
+                    // Check if the requested orientation is either of the landscape orientations and any landscape orientation is supported.
+                    if ((value == DisplayOrientation.LandscapeLeft || value == DisplayOrientation.LandscapeRight) &&
+                        ((supported & (DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight)) != 0))
+                    {
+                        didOrientationChange = true;
+                        _currentOrientation = DisplayOrientation.LandscapeLeft;
+                        requestedOrientation = ScreenOrientation.Landscape;
+                        requestPortrait = false;
+                    }
+                    // Check if the requested orientation is either of the portrain orientations and any portrait orientation is supported.
+                    else if ((value == DisplayOrientation.Portrait || value == DisplayOrientation.PortraitDown) &&
+                            ((supported & (DisplayOrientation.Portrait | DisplayOrientation.PortraitDown)) != 0))
+                    {
+                        didOrientationChange = true;
+                        _currentOrientation = DisplayOrientation.Portrait;
+                        requestedOrientation = ScreenOrientation.Portrait;
+                        requestPortrait = true;
+                    }
+                }
+
+                if (didOrientationChange)
+                {
+                    // Android doesn't fire Released events for existing touches
+                    // so we need to clear them out.
+                    if (wasPortrait != requestPortrait)
+                    {
+                        TouchPanelState.ReleaseAllTouches();
+                    }
+
+                    OnOrientationChanged();
+                }
+            }
+        }
+
+
+        public void Dispose()
+        {
+            if (GameView != null)
+            {
+                GameView.Dispose();
+                GameView = null;
+            }
+        }
+
+        public override void BeginScreenDeviceChange(bool willBeFullScreen)
+        {
+        }
+
+        public override void EndScreenDeviceChange(string screenDeviceName, int clientWidth, int clientHeight)
+        {
+        }
+
+        protected override void SetTitle(string title)
+        {
+        }
+    }
+}
diff --git a/MonoGame.Framework/Android/Devices/Sensors/Accelerometer.cs b/MonoGame.Framework/Android/Devices/Sensors/Accelerometer.cs
new file mode 100644
index 00000000000..740043e53a9
--- /dev/null
+++ b/MonoGame.Framework/Android/Devices/Sensors/Accelerometer.cs
@@ -0,0 +1,208 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Android.Content;
+using Android.Hardware;
+using Microsoft.Xna.Framework;
+
+namespace Microsoft.Devices.Sensors
+{
+    /// <summary>
+    /// Provides Android applications access to the device’s accelerometer sensor.
+    /// </summary>
+    public sealed class Accelerometer : SensorBase<AccelerometerReading>
+    {
+        static readonly int MaxSensorCount = 10;
+        static SensorManager sensorManager;
+        static Sensor sensor;
+        SensorListener listener;
+        SensorState state;
+        bool started = false;
+        static int instanceCount;
+
+        /// <summary>
+        /// Gets or sets whether the device on which the application is running supports the accelerometer sensor.
+        /// </summary>
+        public static bool IsSupported
+        {
+            get
+            {
+                if (sensorManager == null)
+                    Initialize();
+                return sensor != null;
+            }
+        }
+
+        /// <summary>
+        /// Gets the current state of the accelerometer. The value is a member of the SensorState enumeration.
+        /// </summary>
+        public SensorState State
+        {
+            get
+            {
+                if (IsDisposed)
+                    throw new ObjectDisposedException(GetType().Name);
+                if (sensorManager == null)
+                {
+                    Initialize();
+                    state = sensor != null ? SensorState.Initializing : SensorState.NotSupported;
+                }
+                return state;
+            }
+        }
+
+        /// <summary>
+        /// Creates a new instance of the Accelerometer object.
+        /// </summary>
+        public Accelerometer()
+        {
+            if (instanceCount >= MaxSensorCount)
+                throw new SensorFailedException("The limit of 10 simultaneous instances of the Accelerometer class per application has been exceeded.");
+            ++instanceCount;
+
+            state = sensor != null ? SensorState.Initializing : SensorState.NotSupported;
+            listener = new SensorListener();
+        }
+
+        /// <summary>
+        /// Initializes the platform resources required for the accelerometer sensor.
+        /// </summary>
+        static void Initialize()
+        {
+            sensorManager = (SensorManager)Game.Activity.GetSystemService(Context.SensorService);
+            sensor = sensorManager.GetDefaultSensor(SensorType.Accelerometer);
+        }
+
+        void ActivityPaused(object sender, EventArgs eventArgs)
+        {
+            sensorManager.UnregisterListener(listener, sensor);
+        }
+
+        void ActivityResumed(object sender, EventArgs eventArgs)
+        {
+            sensorManager.RegisterListener(listener, sensor, SensorDelay.Game);
+        }
+
+        /// <summary>
+        /// Starts data acquisition from the accelerometer.
+        /// </summary>
+        public override void Start()
+        {
+            if (IsDisposed)
+                throw new ObjectDisposedException(GetType().Name);
+            if (sensorManager == null)
+                Initialize();
+            if (started == false)
+            {
+                if (sensorManager != null && sensor != null)
+                {
+                    listener.accelerometer = this;
+                    sensorManager.RegisterListener(listener, sensor, SensorDelay.Game);
+                    // So the system can pause and resume the sensor when the activity is paused
+                    AndroidGameActivity.Paused += ActivityPaused;
+                    AndroidGameActivity.Resumed += ActivityResumed;
+                }
+                else
+                {
+                    throw new AccelerometerFailedException("Failed to start accelerometer data acquisition. No default sensor found.", -1);
+                }
+                started = true;
+                state = SensorState.Ready;
+                return;
+            }
+            else
+            {
+                throw new AccelerometerFailedException("Failed to start accelerometer data acquisition. Data acquisition already started.", -1);
+            }
+        }
+
+        /// <summary>
+        /// Stops data acquisition from the accelerometer.
+        /// </summary>
+        public override void Stop()
+        {
+            if (IsDisposed)
+                throw new ObjectDisposedException(GetType().Name);
+            if (started)
+            {
+                if (sensorManager != null && sensor != null)
+                {
+                    AndroidGameActivity.Paused -= ActivityPaused;
+                    AndroidGameActivity.Resumed -= ActivityResumed;
+                    sensorManager.UnregisterListener(listener, sensor);
+                    listener.accelerometer = null;
+                }
+            }
+            started = false;
+            state = SensorState.Disabled;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                if (disposing)
+                {
+                    if (started)
+                        Stop();
+                    --instanceCount;
+                    if (instanceCount == 0)
+                    {
+                        sensor = null;
+                        sensorManager = null;
+                    }
+                }
+            }
+            base.Dispose(disposing);
+        }
+
+        class SensorListener : Java.Lang.Object, ISensorEventListener
+        {
+            internal Accelerometer accelerometer;
+
+            public void OnAccuracyChanged(Sensor sensor, SensorStatus accuracy)
+            {
+                //do nothing
+            }
+
+            public void OnSensorChanged(SensorEvent e)
+            {
+                try
+                {
+                    if (e != null && e.Sensor.Type == SensorType.Accelerometer && accelerometer != null)
+                    {
+                        var values = e.Values;
+                        try
+                        {
+                            AccelerometerReading reading = new AccelerometerReading();
+                            accelerometer.IsDataValid = (values != null && values.Count == 3);
+                            if (accelerometer.IsDataValid)
+                            {
+                                const float gravity = Android.Hardware.SensorManager.GravityEarth;
+                                reading.Acceleration = new Vector3(values[0], values[1], values[2]) / gravity;
+                                reading.Timestamp = DateTime.UtcNow;
+                            }
+                            accelerometer.CurrentValue = reading;
+                        }
+                        finally
+                        {
+                            IDisposable d = values as IDisposable;
+                            if (d != null)
+                                d.Dispose();
+                        }
+                    }
+                }
+                catch (NullReferenceException)
+                {
+                    //Occassionally an NullReferenceException is thrown when accessing e.Values??
+                    // mono    : Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object
+                    // mono    :   at Android.Runtime.JNIEnv.GetObjectField (IntPtr jobject, IntPtr jfieldID) [0x00000] in <filename unknown>:0 
+                    // mono    :   at Android.Hardware.SensorEvent.get_Values () [0x00000] in <filename unknown>:0
+                }
+            }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Android/Devices/Sensors/Compass.cs b/MonoGame.Framework/Android/Devices/Sensors/Compass.cs
new file mode 100644
index 00000000000..8846603e96b
--- /dev/null
+++ b/MonoGame.Framework/Android/Devices/Sensors/Compass.cs
@@ -0,0 +1,228 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Android.Content;
+using Android.Hardware;
+using Microsoft.Xna.Framework;
+
+namespace Microsoft.Devices.Sensors
+{
+    /// <summary>
+    /// Provides Android applications access to the device’s compass sensor.
+    /// </summary>
+    public sealed class Compass : SensorBase<CompassReading>
+    {
+        static readonly int MaxSensorCount = 10;
+        static SensorManager sensorManager;
+        static Sensor sensorMagneticField;
+        static Sensor sensorAccelerometer;
+        SensorListener listener;
+        SensorState state;
+        bool started = false;
+        static int instanceCount;
+
+        /// <summary>
+        /// Gets whether the device on which the application is running supports the compass sensor.
+        /// </summary>
+        public static bool IsSupported
+        {
+            get
+            {
+                if (sensorManager == null)
+                    Initialize();
+                return sensorMagneticField != null;
+            }
+        }
+
+        /// <summary>
+        /// Gets the current state of the compass. The value is a member of the SensorState enumeration.
+        /// </summary>
+        public SensorState State
+        {
+            get
+            {
+                if (IsDisposed)
+                    throw new ObjectDisposedException(GetType().Name);
+                if (sensorManager == null)
+                    Initialize();
+                return state;
+            }
+        }
+
+        /// <summary>
+        /// Creates a new instance of the Compass object.
+        /// </summary>
+        public Compass()
+        {
+            if (instanceCount >= MaxSensorCount)
+                throw new SensorFailedException("The limit of 10 simultaneous instances of the Compass class per application has been exceeded.");
+            ++instanceCount;
+
+            state = sensorMagneticField != null ? SensorState.Initializing : SensorState.NotSupported;
+            listener = new SensorListener();
+        }
+
+        /// <summary>
+        /// Initializes the platform resources required for the compass sensor.
+        /// </summary>
+        static void Initialize()
+        {
+            sensorManager = (SensorManager)Game.Activity.GetSystemService(Context.SensorService);
+            sensorMagneticField = sensorManager.GetDefaultSensor(SensorType.MagneticField);
+            sensorAccelerometer = sensorManager.GetDefaultSensor(SensorType.Accelerometer);
+        }
+
+        void ActivityPaused(object sender, EventArgs eventArgs)
+        {
+            sensorManager.UnregisterListener(listener, sensorMagneticField);
+            sensorManager.UnregisterListener(listener, sensorAccelerometer);
+        }
+
+        void ActivityResumed(object sender, EventArgs eventArgs)
+        {
+            sensorManager.RegisterListener(listener, sensorAccelerometer, SensorDelay.Game);
+            sensorManager.RegisterListener(listener, sensorMagneticField, SensorDelay.Game);
+        }
+
+        /// <summary>
+        /// Starts data acquisition from the compass.
+        /// </summary>
+        public override void Start()
+        {
+            if (IsDisposed)
+                throw new ObjectDisposedException(GetType().Name);
+            if (sensorManager == null)
+                Initialize();
+            if (started == false)
+            {
+                if (sensorManager != null && sensorMagneticField != null && sensorAccelerometer != null)
+                {
+                    listener.compass = this;
+                    sensorManager.RegisterListener(listener, sensorMagneticField, SensorDelay.Game);
+                    sensorManager.RegisterListener(listener, sensorAccelerometer, SensorDelay.Game);
+                }
+                else
+                {
+                    throw new SensorFailedException("Failed to start compass data acquisition. No default sensor found.");
+                }
+                started = true;
+                state = SensorState.Ready;
+                return;
+            }
+            else
+            {
+                throw new SensorFailedException("Failed to start compass data acquisition. Data acquisition already started.");
+            }
+        }
+
+        /// <summary>
+        /// Stops data acquisition from the accelerometer.
+        /// </summary>
+        public override void Stop()
+        {
+            if (IsDisposed)
+                throw new ObjectDisposedException(GetType().Name);
+            if (started)
+            {
+                if (sensorManager != null && sensorMagneticField != null && sensorAccelerometer != null)
+                {
+                    sensorManager.UnregisterListener(listener, sensorAccelerometer);
+                    sensorManager.UnregisterListener(listener, sensorMagneticField);
+                    listener.compass = null;
+                }
+            }
+            started = false;
+            state = SensorState.Disabled;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                if (disposing)
+                {
+                    if (started)
+                        Stop();
+                    --instanceCount;
+                    if (instanceCount == 0)
+                    {
+                        sensorAccelerometer = null;
+                        sensorMagneticField = null;
+                        sensorManager = null;
+                    }
+                }
+            }
+            base.Dispose(disposing);
+        }
+
+        class SensorListener : Java.Lang.Object, ISensorEventListener
+        {
+            internal Compass compass;
+            float[] valuesAccelerometer;
+            float[] valuesMagenticField;
+            float[] matrixR;
+            float[] matrixI;
+            float[] matrixValues;
+
+            public SensorListener()
+            {
+                valuesAccelerometer = new float[3];
+                valuesMagenticField = new float[3];
+                matrixR = new float[9];
+                matrixI = new float[9];
+                matrixValues = new float[3];
+            }
+
+            public void OnAccuracyChanged(Sensor sensor, SensorStatus accuracy)
+            {
+                //do nothing
+            }
+
+            public void OnSensorChanged(SensorEvent e)
+            {
+                try
+                {
+                    switch (e.Sensor.Type)
+                    {
+                        case SensorType.Accelerometer:
+                            valuesAccelerometer[0] = e.Values[0];
+                            valuesAccelerometer[1] = e.Values[1];
+                            valuesAccelerometer[2] = e.Values[2];
+                            break;
+
+                        case SensorType.MagneticField:
+                            valuesMagenticField[0] = e.Values[0];
+                            valuesMagenticField[1] = e.Values[1];
+                            valuesMagenticField[2] = e.Values[2];
+                            break;
+                    }
+
+                    compass.IsDataValid = SensorManager.GetRotationMatrix(matrixR, matrixI, valuesAccelerometer, valuesMagenticField);
+                    if (compass.IsDataValid)
+                    {
+                        SensorManager.GetOrientation(matrixR, matrixValues);
+                        CompassReading reading = new CompassReading();
+                        reading.MagneticHeading = matrixValues[0];
+                        Vector3 magnetometer = new Vector3(valuesMagenticField[0], valuesMagenticField[1], valuesMagenticField[2]);
+                        reading.MagnetometerReading = magnetometer;
+                        // We need the magnetic declination from true north to calculate the true heading from the magnetic heading.
+                        // On Android, this is available through Android.Hardware.GeomagneticField, but this requires your geo position.
+                        reading.TrueHeading = reading.MagneticHeading;
+                        reading.Timestamp = DateTime.UtcNow;
+                        compass.CurrentValue = reading;
+                    }
+                }
+                catch (NullReferenceException)
+                {
+                    //Occassionally an NullReferenceException is thrown when accessing e.Values??
+                    // mono    : Unhandled Exception: System.NullReferenceException: Object reference not set to an instance of an object
+                    // mono    :   at Android.Runtime.JNIEnv.GetObjectField (IntPtr jobject, IntPtr jfieldID) [0x00000] in <filename unknown>:0 
+                    // mono    :   at Android.Hardware.SensorEvent.get_Values () [0x00000] in <filename unknown>:0
+                }
+            }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Android/GamerServices/Guide.cs b/MonoGame.Framework/Android/GamerServices/Guide.cs
new file mode 100644
index 00000000000..2ecb9983ac3
--- /dev/null
+++ b/MonoGame.Framework/Android/GamerServices/Guide.cs
@@ -0,0 +1,402 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+#region Using clause
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Runtime.Remoting.Messaging;
+using Android.App;
+using Android.Content;
+using Android.Views;
+using Android.Widget;
+using Microsoft.Xna.Framework.Net;
+
+
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	public static class Guide
+	{
+		private static bool isScreenSaverEnabled;
+		private static bool isTrialMode;
+		private static bool isVisible;
+		private static bool simulateTrialMode;
+
+        internal static void Initialise(Game game)
+        {
+			MonoGameGamerServicesHelper.Initialise(game);        
+        }
+
+        delegate string ShowKeyboardInputDelegate(
+          PlayerIndex player,           
+         string title,
+         string description,
+         string defaultText,
+          bool usePasswordMode);
+
+         public static string ShowKeyboardInput(
+          PlayerIndex player,           
+          string title,
+          string description,
+          string defaultText,
+          bool usePasswordMode)
+         {
+            string result = null;
+            EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
+
+            IsVisible = true;
+
+            Game.Activity.RunOnUiThread(() => 
+            {
+                var alert = new AlertDialog.Builder(Game.Activity);
+
+                alert.SetTitle(title);
+                alert.SetMessage(description);
+
+                var input = new EditText(Game.Activity) { Text = defaultText };
+                if (defaultText != null)
+                {
+                    input.SetSelection(defaultText.Length);
+                }
+                if (usePasswordMode)
+                {
+                    input.InputType = Android.Text.InputTypes.ClassText | Android.Text.InputTypes.TextVariationPassword;
+                }
+                alert.SetView(input);
+
+                alert.SetPositiveButton("Ok", (dialog, whichButton) =>
+                {
+                    result = input.Text;
+                    IsVisible = false;
+                    waitHandle.Set();
+                });
+
+                alert.SetNegativeButton("Cancel", (dialog, whichButton) =>
+                {
+                    result = null;
+                    IsVisible = false;
+                    waitHandle.Set();
+                });
+                alert.SetCancelable(false);
+                alert.Show();
+
+            });
+            waitHandle.WaitOne();
+            IsVisible = false;
+
+            return result;
+        }
+
+        public static IAsyncResult BeginShowKeyboardInput (
+         PlayerIndex player,
+         string title,
+         string description,
+         string defaultText,
+         AsyncCallback callback,
+         Object state)
+        {
+            return BeginShowKeyboardInput(player, title, description, defaultText, callback, state, false );
+        }
+
+        public static IAsyncResult BeginShowKeyboardInput (
+         PlayerIndex player,
+         string title,
+         string description,
+         string defaultText,
+         AsyncCallback callback,
+         Object state,
+         bool usePasswordMode)
+		{
+			if (IsVisible)
+				throw new GuideAlreadyVisibleException("The function cannot be completed at this time: the Guide UI is already active. Wait until Guide.IsVisible is false before issuing this call.");
+
+			IsVisible = true;
+
+			ShowKeyboardInputDelegate ski = ShowKeyboardInput; 
+
+			return ski.BeginInvoke(player, title, description, defaultText, usePasswordMode, callback, ski);
+		}
+
+		public static string EndShowKeyboardInput (IAsyncResult result)
+		{
+			try 
+			{
+				return (result.AsyncState as ShowKeyboardInputDelegate).EndInvoke(result);
+			} 
+			finally 
+			{
+				IsVisible = false;
+			}			
+		}
+
+		delegate Nullable<int> ShowMessageBoxDelegate( string title,
+         string text,
+         IEnumerable<string> buttons,
+         int focusButton,
+         MessageBoxIcon icon);
+
+		public static Nullable<int> ShowMessageBox( string title,
+         string text,
+         IEnumerable<string> buttons,
+         int focusButton,
+         MessageBoxIcon icon)
+		{
+			Nullable<int> result = null;
+
+			IsVisible = true;
+			EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
+
+			Game.Activity.RunOnUiThread(() => {
+				AlertDialog.Builder alert = new AlertDialog.Builder(Game.Activity);
+
+				alert.SetTitle(title);
+				alert.SetMessage(text);
+
+				alert.SetPositiveButton(buttons.ElementAt(0), (dialog, whichButton) =>
+				{ 
+					result = 0;
+					IsVisible = false;
+					waitHandle.Set();
+				});
+
+				if (buttons.Count() == 2)
+					alert.SetNegativeButton(buttons.ElementAt(1), (dialog, whichButton) => 
+					{ 
+						result = 1;
+						IsVisible = false;
+						waitHandle.Set();
+					});
+				alert.SetCancelable(false);
+                
+				alert.Show();
+			});
+			waitHandle.WaitOne();
+			IsVisible = false;
+	
+			return result;
+		}
+
+		public static IAsyncResult BeginShowMessageBox(
+         PlayerIndex player,
+         string title,
+         string text,
+         IEnumerable<string> buttons,
+         int focusButton,
+         MessageBoxIcon icon,
+         AsyncCallback callback,
+         Object state
+		)
+		{
+			if (IsVisible)
+				throw new GuideAlreadyVisibleException("The function cannot be completed at this time: the Guide UI is already active. Wait until Guide.IsVisible is false before issuing this call.");
+			
+			IsVisible = true;
+			
+			ShowMessageBoxDelegate smb = ShowMessageBox; 
+
+			return smb.BeginInvoke(title, text, buttons, focusButton, icon, callback, smb);			
+		}
+
+		public static IAsyncResult BeginShowMessageBox (
+         string title,
+         string text,
+         IEnumerable<string> buttons,
+         int focusButton,
+         MessageBoxIcon icon,
+         AsyncCallback callback,
+         Object state
+		)
+		{
+			return BeginShowMessageBox(PlayerIndex.One, title, text, buttons, focusButton, icon, callback, state);
+		}
+
+		public static Nullable<int> EndShowMessageBox (IAsyncResult result)
+		{
+			try
+			{
+				return (result.AsyncState as ShowMessageBoxDelegate).EndInvoke(result);
+			} 
+			finally 
+			{
+				IsVisible = false;
+			}
+		}
+
+
+		public static void ShowMarketplace (PlayerIndex player )
+		{
+			string packageName = Game.Activity.PackageName;
+			try
+			{
+				Intent intent = new Intent(Intent.ActionView);
+				intent.SetData(Android.Net.Uri.Parse("market://details?id=" + packageName));
+				intent.SetFlags(ActivityFlags.NewTask);
+				Game.Activity.StartActivity(intent);
+			}
+			catch (ActivityNotFoundException)
+			{
+				Intent intent = new Intent(Intent.ActionView);
+				intent.SetData(Android.Net.Uri.Parse("http://play.google.com/store/apps/details?id=" + packageName));
+				intent.SetFlags(ActivityFlags.NewTask);
+				Game.Activity.StartActivity(intent);
+			}
+		}
+
+		public static void Show ()
+		{
+			ShowSignIn(1, false);
+		}
+
+		public static void ShowSignIn (int paneCount, bool onlineOnly)
+		{
+			if ( paneCount != 1 )
+			{
+				new ArgumentException("paneCount Can only be 1 on iPhone");
+				return;
+			}
+			
+			MonoGameGamerServicesHelper.ShowSigninSheet();
+
+			if (GamerServicesComponent.LocalNetworkGamer == null)
+			{
+				GamerServicesComponent.LocalNetworkGamer = new LocalNetworkGamer();
+			}
+			else
+			{
+				GamerServicesComponent.LocalNetworkGamer.SignedInGamer.BeginAuthentication(null, null);
+			}
+		}
+
+		public static void ShowLeaderboard()
+		{
+			if ( ( Gamer.SignedInGamers.Count > 0 ) && ( Gamer.SignedInGamers[0].IsSignedInToLive ) )
+			{
+				
+			}
+		}
+
+		public static void ShowAchievements()
+		{
+			if ( ( Gamer.SignedInGamers.Count > 0 ) && ( Gamer.SignedInGamers[0].IsSignedInToLive ) )
+			{
+				
+			}
+		}
+		
+		public static void ShowPeerPicker()
+		{
+			if ( ( Gamer.SignedInGamers.Count > 0 ) && ( Gamer.SignedInGamers[0].IsSignedInToLive ) )
+			{
+				
+			}
+		}
+		
+		
+		public static void ShowMatchMaker()
+		{
+			if ( ( Gamer.SignedInGamers.Count > 0 ) && ( Gamer.SignedInGamers[0].IsSignedInToLive ) )
+			{
+			
+			}
+		}
+
+		#region Properties
+		public static bool IsScreenSaverEnabled 
+		{ 
+			get
+			{
+				return isScreenSaverEnabled;
+			}
+			set
+			{
+				isScreenSaverEnabled = value;
+			}
+		}
+
+		public static bool IsTrialMode 
+		{ 
+			get
+			{
+				return isTrialMode;
+			}
+			set
+			{
+				isTrialMode = value;
+			}
+		}
+
+		public static bool IsVisible 
+		{ 
+			get
+			{
+				return isVisible;
+			}
+			internal set
+			{
+				isVisible = value;
+			}
+		}
+
+		public static bool SimulateTrialMode 
+		{ 
+			get
+			{
+				return simulateTrialMode;
+			}
+			set
+			{
+				simulateTrialMode = value;
+			}
+		}
+
+		[CLSCompliant(false)]
+		public static AndroidGameWindow Window 
+		{ 
+			get;
+			set;
+		}
+		#endregion
+		
+	}
+}
diff --git a/MonoGame.Framework/Android/GamerServices/MonoGameGamerServicesHelper.cs b/MonoGame.Framework/Android/GamerServices/MonoGameGamerServicesHelper.cs
new file mode 100644
index 00000000000..6fc33816d3b
--- /dev/null
+++ b/MonoGame.Framework/Android/GamerServices/MonoGameGamerServicesHelper.cs
@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Diagnostics;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    internal class MonoGameGamerServicesHelper
+    {
+        private static MonoLiveGuide guide = null;
+
+        
+
+        public static void ShowSigninSheet()
+        {
+            guide.Enabled = true;
+			guide.Visible = true;
+            Guide.IsVisible = true;
+        }
+    
+        internal static void Initialise(Game game)
+        {
+            if (guide == null)
+            {
+                guide = new MonoLiveGuide(game);                
+                game.Components.Add(guide);
+            }
+        }}
+
+    internal class MonoLiveGuide : DrawableGameComponent
+    {
+        SpriteBatch spriteBatch;
+        Texture2D signInProgress;
+        Color alphaColor = new Color(128, 128, 128, 0);
+        byte startalpha = 0;
+
+        public MonoLiveGuide(Game game)
+            : base(game)
+        {
+            this.Enabled = false;
+            this.Visible = false;
+            //Guide.IsVisible = false;
+            this.DrawOrder = Int32.MaxValue;
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+        }
+
+        Texture2D Circle(GraphicsDevice graphics, int radius)
+        {
+            int aDiameter = radius * 2;
+            Vector2 aCenter = new Vector2(radius, radius);
+
+            Texture2D aCircle = new Texture2D(graphics, aDiameter, aDiameter, false, SurfaceFormat.Color);
+            Color[] aColors = new Color[aDiameter * aDiameter];
+
+            for (int i = 0; i < aColors.Length; i++)
+            {
+                int x = (i + 1) % aDiameter;
+                int y = (i + 1) / aDiameter;
+
+                Vector2 aDistance = new Vector2(Math.Abs(aCenter.X - x), Math.Abs(aCenter.Y - y));
+
+
+                if (Math.Sqrt((aDistance.X * aDistance.X) + (aDistance.Y * aDistance.Y)) > radius)
+                {
+                    aColors[i] = Color.Transparent;
+                }
+                else
+                {
+                    aColors[i] = Color.White;
+                }
+            }
+
+            aCircle.SetData<Color>(aColors);
+
+            return aCircle;
+        }
+
+        protected override void LoadContent()
+        {
+            spriteBatch = new SpriteBatch(this.Game.GraphicsDevice);
+
+            signInProgress = Circle(this.Game.GraphicsDevice, 10);
+
+            base.LoadContent();
+        }
+
+        protected override void UnloadContent()
+        {
+            base.UnloadContent();
+        }
+
+        public override void Draw(GameTime gameTime)
+        {
+            spriteBatch.Begin();//SpriteSortMode.Immediate, BlendState.AlphaBlend);
+
+            Vector2 center = new Vector2(this.Game.GraphicsDevice.Viewport.Width / 2, this.Game.GraphicsDevice.Viewport.Height - 100);
+            Vector2 loc = Vector2.Zero;
+            alphaColor.A = startalpha;
+            for (int i = 0; i < 12; i++)
+            {
+                float angle = (float)(i / 12.0 * Math.PI * 2);
+                loc = new Vector2(center.X + (float)Math.Cos(angle) * 50, center.Y + (float)Math.Sin(angle) * 50);
+                spriteBatch.Draw(signInProgress, loc, alphaColor);
+                alphaColor.A += 255 / 12;
+                if (alphaColor.A > 255) alphaColor.A = 0;
+            }
+            spriteBatch.End();
+            base.Draw(gameTime);
+        }
+
+        TimeSpan gt = TimeSpan.Zero;
+        TimeSpan last = TimeSpan.Zero;
+		int delay = 2;
+
+        public override void Update(GameTime gameTime)
+        {
+            if (gt == TimeSpan.Zero) gt = last = gameTime.TotalGameTime;
+
+            if ((gameTime.TotalGameTime - last).Milliseconds > 100)
+            {
+                last = gameTime.TotalGameTime;
+                startalpha += 255 / 12;
+            }
+
+            if ((gameTime.TotalGameTime - gt).TotalSeconds > delay) // close after 10 seconds
+            {
+				
+				string name = "androiduser";
+				try
+				{
+					Android.Accounts.AccountManager mgr = (Android.Accounts.AccountManager)Android.App.Application.Context.GetSystemService(Android.App.Activity.AccountService);
+					if (mgr != null)
+					{
+						var accounts = mgr.GetAccounts();
+						if (accounts != null && accounts.Length > 0)
+						{							
+							name = accounts[0].Name;
+							if (name.Contains("@"))
+							{
+								// its an email 
+								name = name.Substring(0, name.IndexOf("@"));
+							}
+						}
+					}
+				}
+				catch
+				{
+				}
+				
+                SignedInGamer sig = new SignedInGamer();
+                sig.DisplayName = name;
+                sig.Gamertag = name;
+				sig.IsSignedInToLive = false;
+
+                Gamer.SignedInGamers.Add(sig);
+
+                this.Visible = false;
+                this.Enabled = false;
+                //Guide.IsVisible = false;
+                gt = TimeSpan.Zero;
+            }
+            base.Update(gameTime);
+        }
+
+    }
+}
+
+
diff --git a/MonoGame.Framework/Android/GamerServices/SignedInGamer.cs b/MonoGame.Framework/Android/GamerServices/SignedInGamer.cs
new file mode 100644
index 00000000000..0f459af2342
--- /dev/null
+++ b/MonoGame.Framework/Android/GamerServices/SignedInGamer.cs
@@ -0,0 +1,341 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+#region Statement
+using System;
+
+using Android.Net;
+
+#endregion Statement
+
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    public class SignedInGamer : Gamer
+    {
+		// TODO private GKLocalPlayer lp;
+		
+		private AchievementCollection gamerAchievements;
+		private FriendCollection friendCollection;
+		private bool isSignedInToLive = true;
+		
+		delegate void AuthenticationDelegate();
+		
+		public IAsyncResult BeginAuthentication(AsyncCallback callback, Object asyncState)
+		{
+			// Go off authenticate
+			AuthenticationDelegate ad = DoAuthentication; 
+			
+			return ad.BeginInvoke(callback, ad);
+		}
+		
+		public void EndAuthentication( IAsyncResult result )
+		{
+			AuthenticationDelegate ad = (AuthenticationDelegate)result.AsyncState; 
+			
+			ad.EndInvoke(result);
+		}
+		
+		private void DoAuthentication()
+		{
+			try 				
+			{
+				
+			}
+			catch (Exception ex) 
+			{
+				Console.WriteLine(ex.Message);
+			}
+		}
+		
+		public SignedInGamer()
+		{		
+			var result = BeginAuthentication(null, null);	
+			EndAuthentication( result );
+		}
+		
+		private void AuthenticationCompletedCallback( IAsyncResult result )
+		{
+			EndAuthentication(result);	
+		}
+		
+		#region Methods
+		public FriendCollection GetFriends()
+		{
+			if(IsSignedInToLive)
+			{
+				if ( friendCollection == null )
+				{
+					friendCollection = new FriendCollection();
+				}
+			}
+			
+			return friendCollection;
+		}
+		
+		public bool IsFriend (Gamer gamer)
+		{
+			if ( gamer == null ) 
+				throw new ArgumentNullException();
+			
+			if ( gamer.IsDisposed )
+				throw new ObjectDisposedException(gamer.ToString());	
+			
+			bool found = false;
+			foreach(FriendGamer f in friendCollection)
+			{
+				if ( f.Gamertag == gamer.Gamertag )
+				{
+					found = true;
+				}
+			}
+			return found;
+						
+		}
+		
+		delegate AchievementCollection GetAchievementsDelegate();
+		
+		public IAsyncResult BeginGetAchievements( AsyncCallback callback, Object asyncState)
+		{
+			// Go off and grab achievements
+			GetAchievementsDelegate gad = GetAchievements; 
+			
+			return gad.BeginInvoke(callback, gad);
+		}
+		
+		private void GetAchievementCompletedCallback( IAsyncResult result )
+		{
+			// get the delegate that was used to call that method
+			GetAchievementsDelegate gad = (GetAchievementsDelegate)result.AsyncState; 
+
+			// get the return value from that method call
+			gamerAchievements = gad.EndInvoke(result);
+		}
+		
+		public AchievementCollection EndGetAchievements( IAsyncResult result )
+		{
+			GetAchievementsDelegate gad = (GetAchievementsDelegate)result.AsyncState; 
+			
+			gamerAchievements = gad.EndInvoke(result);
+			
+			return gamerAchievements;
+		}
+		
+		public AchievementCollection GetAchievements()
+		{
+			if ( IsSignedInToLive )
+			{
+				if (gamerAchievements == null)
+				{
+					gamerAchievements = new AchievementCollection();
+				}				
+			}
+			return gamerAchievements;
+		}
+		
+		delegate void AwardAchievementDelegate(string achievementId, double percentageComplete);
+
+        public IAsyncResult BeginAwardAchievement(string achievementId, AsyncCallback callback, Object state)
+        {
+            return BeginAwardAchievement(achievementId, 100.0, callback, state);
+        }
+
+		public IAsyncResult BeginAwardAchievement(
+         string achievementId,
+		 double percentageComplete,
+         AsyncCallback callback,
+         Object state
+		)
+		{	
+			// Go off and award the achievement
+			AwardAchievementDelegate aad = DoAwardAchievement; 
+				
+			return aad.BeginInvoke(achievementId, percentageComplete, callback, aad);
+		}
+		
+		public void EndAwardAchievement(IAsyncResult result)
+		{
+			AwardAchievementDelegate aad = (AwardAchievementDelegate)result.AsyncState; 
+			
+			aad.EndInvoke(result);
+		}
+		
+		private void AwardAchievementCompletedCallback( IAsyncResult result )
+		{
+			EndAwardAchievement(result);	
+		}
+		
+		public void AwardAchievement( string achievementId )
+		{			
+			AwardAchievement(achievementId, 100.0f);
+		}
+		
+		public void DoAwardAchievement( string achievementId, double percentageComplete )
+		{
+			
+		}
+		
+		public void AwardAchievement( string achievementId, double percentageComplete )
+		{
+			if (IsSignedInToLive)
+			{
+				BeginAwardAchievement( achievementId, percentageComplete, AwardAchievementCompletedCallback, null );
+			}
+		}
+		
+		public void UpdateScore( string aCategory, long aScore )
+		{
+			if (IsSignedInToLive)
+			{
+				
+			}
+		}
+		
+		public void ResetAchievements()
+		{
+			if (IsSignedInToLive)
+			{
+				
+			}
+		}
+
+		#endregion
+			
+		#region Properties
+		public GameDefaults GameDefaults 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+		
+		public bool IsGuest 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+		
+		public bool IsSignedInToLive 
+		{ 
+			get
+			{
+				return isSignedInToLive;
+			}
+			internal set{
+				isSignedInToLive = value;
+			}
+		}
+		
+		public int PartySize 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+			set
+			{
+				throw new NotSupportedException();
+			}
+		}
+		
+        public PlayerIndex PlayerIndex
+        {
+            get
+            {
+                return PlayerIndex.One;
+            }
+        }
+		
+		public GamerPresence Presence 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+
+        GamerPrivileges _privileges = new GamerPrivileges();
+        public GamerPrivileges Privileges
+        {
+            get
+            {
+                return _privileges;
+            }
+        }
+		#endregion
+		
+		
+		protected virtual void OnSignedIn(SignedInEventArgs e)
+		{
+            EventHelpers.Raise(this, SignedIn, e);
+		}
+		
+		protected virtual void OnSignedOut(SignedOutEventArgs e)
+		{
+            EventHelpers.Raise(this, SignedOut, e);
+        }
+
+		
+		#region Events
+		public static event EventHandler<SignedInEventArgs> SignedIn;
+		
+		public static event EventHandler<SignedOutEventArgs> SignedOut;
+		#endregion
+    }
+	
+	public class SignedInEventArgs : EventArgs
+	{
+		public SignedInEventArgs ( SignedInGamer gamer )
+		{
+			
+		}
+	}
+	
+	public class SignedOutEventArgs : EventArgs
+	{
+		public SignedOutEventArgs (SignedInGamer gamer )
+		{
+			
+		}
+	}
+}
diff --git a/MonoGame.Framework/Android/IResumeManager.cs b/MonoGame.Framework/Android/IResumeManager.cs
new file mode 100644
index 00000000000..af421133686
--- /dev/null
+++ b/MonoGame.Framework/Android/IResumeManager.cs
@@ -0,0 +1,63 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2012 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+using System;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Interface for a class that handles resuming after a device lost event.
+    /// In particular, this allows the game to draw something to the screen whilst
+    /// graphics content is reloaded - a potentially lengthy operation.
+    /// </summary>
+    public interface IResumeManager
+    {
+        /// <summary>
+        /// Called at the start of the resume process. Textures should always be reloaded here.
+        /// If using a ContentManager, it should be disposed and recreated.
+        /// </summary>
+        void LoadContent();
+
+        /// <summary>
+        /// Called whilst the game is resuming. Draw something to the screen here.
+        /// </summary>
+        void Draw();
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Android/Input/Keyboard.cs b/MonoGame.Framework/Android/Input/Keyboard.cs
new file mode 100644
index 00000000000..72ee5dcd283
--- /dev/null
+++ b/MonoGame.Framework/Android/Input/Keyboard.cs
@@ -0,0 +1,194 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+// 
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Android.Views;
+
+namespace Microsoft.Xna.Framework.Input
+{
+	public static class Keyboard
+	{
+        private static List<Keys> keys = new List<Keys>();
+
+        private static readonly IDictionary<Keycode, Keys> KeyMap = LoadKeyMap();
+
+        internal static bool KeyDown(Keycode keyCode)
+        {
+            Keys key;
+            if (KeyMap.TryGetValue(keyCode, out key) && key != Keys.None)
+            {
+                if (!keys.Contains(key))
+                    keys.Add(key);
+                return true;
+            }
+            return false;
+        }
+
+        internal static bool KeyUp(Keycode keyCode)
+        {
+            Keys key;
+            if (KeyMap.TryGetValue(keyCode, out key) && key != Keys.None)
+            {
+                if (keys.Contains(key))
+                    keys.Remove(key);
+                return true;
+            }
+            return false;
+        }
+
+        private static IDictionary<Keycode, Keys> LoadKeyMap()
+        {
+            // create a map for every Keycode and default it to none so that every possible key is mapped
+            var maps = Enum.GetValues(typeof (Keycode))
+                .Cast<Keycode>()
+                .ToDictionary(key => key, key => Keys.None);
+
+            // then update it with the actual mappings
+            maps[Keycode.DpadLeft] = Keys.Left;
+            maps[Keycode.DpadRight] = Keys.Right;
+            maps[Keycode.DpadUp] = Keys.Up;
+            maps[Keycode.DpadDown] = Keys.Down;
+            maps[Keycode.DpadCenter] = Keys.Enter;
+            maps[Keycode.Num0] = Keys.D0;
+            maps[Keycode.Num1] = Keys.D1;
+            maps[Keycode.Num2] = Keys.D2;
+            maps[Keycode.Num3] = Keys.D3;
+            maps[Keycode.Num4] = Keys.D4;
+            maps[Keycode.Num5] = Keys.D5;
+            maps[Keycode.Num6] = Keys.D6;
+            maps[Keycode.Num7] = Keys.D7;
+            maps[Keycode.Num8] = Keys.D8;
+            maps[Keycode.Num9] = Keys.D9;
+            maps[Keycode.A] = Keys.A;
+            maps[Keycode.B] = Keys.B;
+            maps[Keycode.C] = Keys.C;
+            maps[Keycode.D] = Keys.D;
+            maps[Keycode.E] = Keys.E;
+            maps[Keycode.F] = Keys.F;
+            maps[Keycode.G] = Keys.G;
+            maps[Keycode.H] = Keys.H;
+            maps[Keycode.I] = Keys.I;
+            maps[Keycode.J] = Keys.J;
+            maps[Keycode.K] = Keys.K;
+            maps[Keycode.L] = Keys.L;
+            maps[Keycode.M] = Keys.M;
+            maps[Keycode.N] = Keys.N;
+            maps[Keycode.O] = Keys.O;
+            maps[Keycode.P] = Keys.P;
+            maps[Keycode.Q] = Keys.Q;
+            maps[Keycode.R] = Keys.R;
+            maps[Keycode.S] = Keys.S;
+            maps[Keycode.T] = Keys.T;
+            maps[Keycode.U] = Keys.U;
+            maps[Keycode.V] = Keys.V;
+            maps[Keycode.W] = Keys.W;
+            maps[Keycode.X] = Keys.X;
+            maps[Keycode.Y] = Keys.Y;
+            maps[Keycode.Z] = Keys.Z;
+            maps[Keycode.Space] = Keys.Space;
+            maps[Keycode.Escape] = Keys.Escape;
+            maps[Keycode.Back] = Keys.Back;
+            maps[Keycode.Home] = Keys.Home;
+            maps[Keycode.Enter] = Keys.Enter;
+            maps[Keycode.Period] = Keys.OemPeriod;
+            maps[Keycode.Comma] = Keys.OemComma;
+            maps[Keycode.Menu] = Keys.Help;
+            maps[Keycode.Search] = Keys.BrowserSearch;
+            maps[Keycode.VolumeUp] = Keys.VolumeUp;
+            maps[Keycode.VolumeDown] = Keys.VolumeDown;
+            maps[Keycode.MediaPause] = Keys.Pause;
+            maps[Keycode.MediaPlayPause] = Keys.MediaPlayPause;
+            maps[Keycode.MediaStop] = Keys.MediaStop;
+            maps[Keycode.MediaNext] = Keys.MediaNextTrack;
+            maps[Keycode.MediaPrevious] = Keys.MediaPreviousTrack;
+            maps[Keycode.Mute] = Keys.VolumeMute;
+            maps[Keycode.AltLeft] = Keys.LeftAlt;
+            maps[Keycode.AltRight] = Keys.RightAlt;
+            maps[Keycode.ShiftLeft] = Keys.LeftShift;
+            maps[Keycode.ShiftRight] = Keys.RightShift;
+            maps[Keycode.Tab] = Keys.Tab;
+            maps[Keycode.Del] = Keys.Delete;
+            maps[Keycode.Minus] = Keys.OemMinus;
+            maps[Keycode.LeftBracket] = Keys.OemOpenBrackets;
+            maps[Keycode.RightBracket] = Keys.OemCloseBrackets;
+            maps[Keycode.Backslash] = Keys.OemBackslash;
+            maps[Keycode.Semicolon] = Keys.OemSemicolon;
+            maps[Keycode.PageUp] = Keys.PageUp;
+            maps[Keycode.PageDown] = Keys.PageDown;
+            maps[Keycode.CtrlLeft] = Keys.LeftControl;
+            maps[Keycode.CtrlRight] = Keys.RightControl;
+            maps[Keycode.CapsLock] = Keys.CapsLock;
+            maps[Keycode.ScrollLock] = Keys.Scroll;
+            maps[Keycode.NumLock] = Keys.NumLock;
+            maps[Keycode.Insert] = Keys.Insert;
+            maps[Keycode.F1] = Keys.F1;
+            maps[Keycode.F2] = Keys.F2;
+            maps[Keycode.F3] = Keys.F3;
+            maps[Keycode.F4] = Keys.F4;
+            maps[Keycode.F5] = Keys.F5;
+            maps[Keycode.F6] = Keys.F6;
+            maps[Keycode.F7] = Keys.F7;
+            maps[Keycode.F8] = Keys.F8;
+            maps[Keycode.F9] = Keys.F9;
+            maps[Keycode.F10] = Keys.F10;
+            maps[Keycode.F11] = Keys.F11;
+            maps[Keycode.F12] = Keys.F12;
+            maps[Keycode.NumpadDivide] = Keys.Divide;
+            maps[Keycode.NumpadMultiply] = Keys.Multiply;
+            maps[Keycode.NumpadSubtract] = Keys.Subtract;
+            maps[Keycode.NumpadAdd] = Keys.Add;
+
+            return maps;
+        }
+
+	    public static KeyboardState GetState()
+		{
+			return new KeyboardState(keys);
+		}
+		
+		public static KeyboardState GetState(PlayerIndex playerIndex)
+		{
+            return new KeyboardState(keys);
+		}
+	}
+}
diff --git a/MonoGame.Framework/Android/Input/Touch/AndroidTouchEventManager.cs b/MonoGame.Framework/Android/Input/Touch/AndroidTouchEventManager.cs
new file mode 100644
index 00000000000..9aacc004a1e
--- /dev/null
+++ b/MonoGame.Framework/Android/Input/Touch/AndroidTouchEventManager.cs
@@ -0,0 +1,80 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using Android.Views;
+
+namespace Microsoft.Xna.Framework.Input.Touch
+{
+    /// <summary>
+    /// Manages touch events for Android. Maps new presses to new touch Ids as per Xna WP7 incrementing touch Id behaviour. 
+    /// This is required as Android reports touch IDs of 0 to 5, which leads to incorrect handling of touch events.
+    /// Motivation and discussion: http://monogame.codeplex.com/discussions/382252
+    /// </summary>
+    class AndroidTouchEventManager
+    {
+        readonly AndroidGameWindow _gameWindow;
+
+        public bool Enabled { get; set; }
+
+        public AndroidTouchEventManager(AndroidGameWindow androidGameWindow)
+        {
+            _gameWindow = androidGameWindow;
+        }
+
+        public void OnTouchEvent(MotionEvent e)
+        {
+            if (!Enabled)
+                return;
+
+            Vector2 position = Vector2.Zero;
+            position.X = e.GetX(e.ActionIndex);
+            position.Y = e.GetY(e.ActionIndex);
+            UpdateTouchPosition(ref position);
+            int id = e.GetPointerId(e.ActionIndex);
+            switch (e.ActionMasked)
+            {
+                // DOWN                
+                case MotionEventActions.Down:
+                case MotionEventActions.PointerDown:
+                    TouchPanel.AddEvent(id, TouchLocationState.Pressed, position);
+                    break;
+                // UP                
+                case MotionEventActions.Up:
+                case MotionEventActions.PointerUp:
+                    TouchPanel.AddEvent(id, TouchLocationState.Released, position);
+                    break;
+                // MOVE                
+                case MotionEventActions.Move:
+                    for (int i = 0; i < e.PointerCount; i++)
+                    {
+                        id = e.GetPointerId(i);
+                        position.X = e.GetX(i);
+                        position.Y = e.GetY(i);
+                        UpdateTouchPosition(ref position);
+                        TouchPanel.AddEvent(id, TouchLocationState.Moved, position);
+                    }
+                    break;
+
+                // CANCEL, OUTSIDE                
+                case MotionEventActions.Cancel:
+                case MotionEventActions.Outside:
+                    for (int i = 0; i < e.PointerCount; i++)
+                    {
+                        id = e.GetPointerId(i);
+                        TouchPanel.AddEvent(id, TouchLocationState.Released, position);
+                    }
+                    break;
+            }
+        }
+
+        void UpdateTouchPosition(ref Vector2 position)
+        {
+            Rectangle clientBounds = _gameWindow.ClientBounds;
+
+            //Fix for ClientBounds
+            position.X -= clientBounds.X;
+            position.Y -= clientBounds.Y;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Android/MonoGameAndroidGameView.cs b/MonoGame.Framework/Android/MonoGameAndroidGameView.cs
new file mode 100644
index 00000000000..17272088898
--- /dev/null
+++ b/MonoGame.Framework/Android/MonoGameAndroidGameView.cs
@@ -0,0 +1,1297 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Android.Content;
+using Android.Media;
+using Android.Runtime;
+using Android.Util;
+using Android.Views;
+using Javax.Microedition.Khronos.Egl;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using Microsoft.Xna.Framework.Input.Touch;
+
+namespace Microsoft.Xna.Framework
+{
+    [CLSCompliant(false)]
+    public class MonoGameAndroidGameView : SurfaceView, ISurfaceHolderCallback, View.IOnTouchListener
+    {
+        // What is the state of the app, for tracking surface recreation inside this class.
+        // This acts as a replacement for the all-out monitor wait approach which caused code to be quite fragile.
+        enum InternalState
+        {
+            Pausing_UIThread,  // set by android UI thread and the game thread process it and transitions into 'Paused' state
+            Resuming_UIThread, // set by android UI thread and the game thread process it and transitions into 'Running' state
+            Exiting,           // set either by game or android UI thread and the game thread process it and transitions into 'Exited' state          
+
+            Paused_GameThread,  // set by game thread after processing 'Pausing' state
+            Running_GameThread, // set by game thread after processing 'Resuming' state
+            Exited_GameThread,  // set by game thread after processing 'Exiting' state
+
+            ForceRecreateSurface, // also used to create the surface the 1st time or when screen orientation changes
+        }
+
+        bool disposed = false;
+        ISurfaceHolder mHolder;
+        System.Drawing.Size size;
+
+        ManualResetEvent _waitForPausedStateProcessed = new ManualResetEvent(false);
+        ManualResetEvent _waitForResumedStateProcessed = new ManualResetEvent(false);
+        ManualResetEvent _waitForExitedStateProcessed = new ManualResetEvent(false);
+
+        AutoResetEvent _waitForMainGameLoop = new AutoResetEvent(false);
+        AutoResetEvent _workerThreadUIRenderingWait = new AutoResetEvent(false);
+
+        object _lockObject = new object();
+
+        volatile InternalState _internalState = InternalState.Exited_GameThread;
+
+        bool androidSurfaceAvailable = false;
+
+        bool glSurfaceAvailable;
+        bool glContextAvailable;
+        bool lostglContext;
+        System.Diagnostics.Stopwatch stopWatch;
+        double tick = 0;
+
+        bool loaded = false;
+
+        Task renderTask;
+        CancellationTokenSource cts = null;
+        private readonly AndroidTouchEventManager _touchManager;
+        private readonly AndroidGameWindow _gameWindow;
+        private readonly Game _game;
+
+        // Events that are triggered on the game thread
+        public static event EventHandler OnPauseGameThread;
+        public static event EventHandler OnResumeGameThread;
+
+        public bool TouchEnabled
+        {
+            get { return _touchManager.Enabled; }
+            set
+            {
+                _touchManager.Enabled = value;
+                SetOnTouchListener(value ? this : null);
+            }
+        }
+
+        public bool IsResuming { get; private set; }
+
+        public MonoGameAndroidGameView(Context context, AndroidGameWindow gameWindow, Game game)
+            : base(context)
+        {
+            _gameWindow = gameWindow;
+            _game = game;
+            _touchManager = new AndroidTouchEventManager(gameWindow);
+            Init();
+        }
+
+        private void Init()
+        {
+            // default
+            mHolder = Holder;
+            // Add callback to get the SurfaceCreated etc events
+            mHolder.AddCallback(this);
+            mHolder.SetType(SurfaceType.Gpu);
+        }
+
+        public void SurfaceChanged(ISurfaceHolder holder, global::Android.Graphics.Format format, int width, int height)
+        {
+            // Set flag to recreate gl surface or rendering can be bad on orienation change or if app 
+            // is closed in one orientation and re-opened in another.
+            lock (_lockObject)
+            {
+                // can only be triggered when main loop is running, is unsafe to overwrite other states
+                if (_internalState == InternalState.Running_GameThread)
+                {
+                    _internalState = InternalState.ForceRecreateSurface;
+                }
+
+            }
+        }
+
+        public void SurfaceCreated(ISurfaceHolder holder)
+        {
+            lock (_lockObject)
+            {
+                androidSurfaceAvailable = true;
+            }
+        }
+
+        public void SurfaceDestroyed(ISurfaceHolder holder)
+        {
+            lock (_lockObject)
+            {
+                androidSurfaceAvailable = false;
+            }
+        }
+
+        public bool OnTouch(View v, MotionEvent e)
+        {
+            _touchManager.OnTouchEvent(e);
+            return true;
+        }
+
+        public virtual void SwapBuffers()
+        {
+            EnsureUndisposed();
+            if (!egl.EglSwapBuffers(eglDisplay, eglSurface))
+            {
+                if (egl.EglGetError() == 0)
+                {
+                    if (lostglContext)
+                        System.Diagnostics.Debug.WriteLine("Lost EGL context" + GetErrorAsString());
+                    lostglContext = true;
+                }
+            }
+
+        }
+
+        public virtual void MakeCurrent()
+        {
+            EnsureUndisposed();
+            if (!egl.EglMakeCurrent(eglDisplay, eglSurface,
+                    eglSurface, eglContext))
+            {
+                System.Diagnostics.Debug.WriteLine("Error Make Current" + GetErrorAsString());
+            }
+
+        }
+
+        public virtual void ClearCurrent()
+        {
+            EnsureUndisposed();
+            if (!egl.EglMakeCurrent(eglDisplay, EGL10.EglNoSurface,
+                EGL10.EglNoSurface, EGL10.EglNoContext))
+            {
+                System.Diagnostics.Debug.WriteLine("Error Clearing Current" + GetErrorAsString());
+            }
+        }
+
+        double updates;
+
+        public bool LogFPS { get; set; }
+        public bool RenderOnUIThread { get; set; }
+
+        public virtual void Run()
+        {
+            Run(0.0);
+        }
+
+        public virtual void Run(double updatesPerSecond)
+        {
+            cts = new CancellationTokenSource();
+            if (LogFPS)
+            {
+                targetFps = currentFps = 0;
+                avgFps = 1;
+            }
+            updates = 1000 / updatesPerSecond;
+
+            //var syncContext = new SynchronizationContext ();
+            var syncContext = SynchronizationContext.Current;
+
+            // We always start a new task, regardless if we render on UI thread or not.
+            renderTask = Task.Factory.StartNew(() =>
+           {
+               WorkerThreadFrameDispatcher(syncContext);
+
+           }, cts.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default)
+                .ContinueWith((t) =>
+               {
+                   OnStopped(EventArgs.Empty);
+               });
+        }
+
+        public virtual void Pause()
+        {
+            EnsureUndisposed();
+
+            // if triggered in quick succession and blocked by graphics device creation, 
+            // pause can be triggered twice, without resume in between on some phones.
+            if (_internalState != InternalState.Running_GameThread)
+            {
+                return;
+            }
+
+            // this guarantees that resume finished processing, since we cannot wait inside resume because we deadlock as surface wouldn't get created
+            if (RenderOnUIThread == false)
+            {
+                _waitForResumedStateProcessed.WaitOne();
+            }
+
+            _waitForMainGameLoop.Reset();  // in case it was enabled
+
+            // happens if pause is called immediately after resume so that the surfaceCreated callback was not called yet.
+            bool isAndroidSurfaceAvalible = false; // use local because the wait below must be outside lock
+            lock (_lockObject)
+            {
+                isAndroidSurfaceAvalible = androidSurfaceAvailable;
+                if (!isAndroidSurfaceAvalible)
+                {
+                    _internalState = InternalState.Paused_GameThread; // prepare for next game loop iteration
+                }
+            }
+
+            lock (_lockObject)
+            {
+                // processing the pausing state only if the surface was created already
+                if (androidSurfaceAvailable)
+                {
+                    _waitForPausedStateProcessed.Reset();
+                    _internalState = InternalState.Pausing_UIThread;
+                }
+            }
+
+            if (RenderOnUIThread == false)
+            {
+                _waitForPausedStateProcessed.WaitOne();
+            }
+        }
+
+        public virtual void Resume()
+        {
+            EnsureUndisposed();
+
+            lock (_lockObject)
+            {
+                _waitForResumedStateProcessed.Reset();
+                _internalState = InternalState.Resuming_UIThread;
+            }
+
+            _waitForMainGameLoop.Set();
+
+            try
+            {
+                if (!IsFocused)
+                    RequestFocus();
+            }
+            catch { }
+
+            // do not wait for state transition here since surface creation must be triggered first
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                Stop();
+            }
+            base.Dispose(disposing);
+        }
+
+        public void Stop()
+        {
+            EnsureUndisposed();
+            if (cts != null)
+            {
+                lock (_lockObject)
+                {
+                    _internalState = InternalState.Exiting;
+                }
+
+                cts.Cancel();
+
+                if (RenderOnUIThread == false)
+                {
+                    _waitForExitedStateProcessed.Reset();
+                }
+
+            }
+        }
+
+        FrameEventArgs renderEventArgs = new FrameEventArgs();
+
+        protected void WorkerThreadFrameDispatcher(SynchronizationContext uiThreadSyncContext)
+        {
+            Threading.ResetThread(Thread.CurrentThread.ManagedThreadId);
+            try
+            {
+                stopWatch = System.Diagnostics.Stopwatch.StartNew();
+                tick = 0;
+                prevUpdateTime = DateTime.Now;
+
+                while (!cts.IsCancellationRequested)
+                {
+                    // either use UI thread to render one frame or this worker thread
+                    bool pauseThread = false;
+                    if (RenderOnUIThread)
+                    {
+                        uiThreadSyncContext.Send((s) =>
+                       {
+                           pauseThread = RunIteration(cts.Token);
+                       }, null);
+                    }
+                    else
+                    {
+                        pauseThread = RunIteration(cts.Token);
+                    }
+
+
+                    if (pauseThread)
+                    {
+                        _waitForPausedStateProcessed.Set();
+                        _waitForMainGameLoop.WaitOne(); // pause this thread
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Log.Error("AndroidGameView", ex.ToString());
+            }
+            finally
+            {
+                bool c = cts.IsCancellationRequested;
+
+                cts = null;
+
+                if (glSurfaceAvailable)
+                    DestroyGLSurface();
+
+                if (glContextAvailable)
+                {
+                    DestroyGLContext();
+                    ContextLostInternal();
+                }
+
+                lock (_lockObject)
+                {
+                    _internalState = InternalState.Exited_GameThread;
+                }
+            }
+
+        }
+
+        DateTime prevUpdateTime;
+        DateTime prevRenderTime;
+        DateTime curUpdateTime;
+        DateTime curRenderTime;
+        FrameEventArgs updateEventArgs = new FrameEventArgs();
+
+        void processStateDefault()
+        {
+            Log.Error("AndroidGameView", "Default case for switch on InternalState in main game loop, exiting");
+
+            lock (_lockObject)
+            {
+                _internalState = InternalState.Exited_GameThread;
+            }
+        }
+
+        void processStateRunning(CancellationToken token)
+        {
+            // do not run game if surface is not avalible
+            lock (_lockObject)
+            {
+                if (!androidSurfaceAvailable)
+                {
+                    return;
+                }
+            }
+
+
+            // check if app wants to exit
+            if (token.IsCancellationRequested)
+            {
+                // change state to exit and skip game loop
+                lock (_lockObject)
+                {
+                    _internalState = InternalState.Exiting;
+                }
+
+                return;
+            }
+
+            try
+            {
+                UpdateAndRenderFrame();
+            }
+            catch (MonoGameGLException ex)
+            {
+                Log.Error("AndroidGameView", "GL Exception occured during RunIteration {0}", ex.Message);
+            }
+
+            if (updates > 0)
+            {
+                var t = updates - (stopWatch.Elapsed.TotalMilliseconds - tick);
+                if (t > 0)
+                {
+                    if (LogFPS)
+                    {
+                        Log.Verbose("AndroidGameView", "took {0:F2}ms, should take {1:F2}ms, sleeping for {2:F2}", stopWatch.Elapsed.TotalMilliseconds - tick, updates, t);
+                    }
+
+                }
+            }
+
+        }
+
+        void processStatePausing()
+        {
+            if (glSurfaceAvailable)
+            {
+                // Surface we are using needs to go away
+                DestroyGLSurface();
+
+                if (loaded)
+                    OnUnload(EventArgs.Empty);
+            }
+
+            // trigger callbacks, must pause openAL device here
+            OnPauseGameThread(this, EventArgs.Empty);
+
+            // go to next state
+            lock (_lockObject)
+            {
+                _internalState = InternalState.Paused_GameThread;
+            }
+        }
+
+        void processStateResuming()
+        {
+            bool isSurfaceAvalible = false;
+            lock (_lockObject)
+            {
+                isSurfaceAvalible = androidSurfaceAvailable;
+            }
+
+            // must sleep outside lock!
+            if (!RenderOnUIThread && !isSurfaceAvalible)
+            {
+                Thread.Sleep(50); // sleep so UI thread easier acquires lock
+                return;
+            }
+
+            // this can happen if pause is triggered immediately after resume so that SurfaceCreated callback doesn't get called yet,
+            // in this case we skip the resume process and pause sets a new state.   
+            lock (_lockObject)
+            {
+                if (!androidSurfaceAvailable)
+                    return;
+
+                // create surface if context is avalible
+                if (glContextAvailable && !lostglContext)
+                {
+                    try
+                    {
+                        CreateGLSurface();
+                    }
+                    catch (Exception ex)
+                    {
+                        // We failed to create the surface for some reason
+                        Log.Verbose("AndroidGameView", ex.ToString());
+                    }
+                }
+
+                // create context if not avalible
+                if ((!glContextAvailable || lostglContext))
+                {
+                    // Start or Restart due to context loss
+                    bool contextLost = false;
+                    if (lostglContext || glContextAvailable)
+                    {
+                        // we actually lost the context
+                        // so we need to free up our existing 
+                        // objects and re-create one.
+                        DestroyGLContext();
+                        contextLost = true;
+
+                        ContextLostInternal();
+                    }
+
+                    CreateGLContext();
+                    CreateGLSurface();
+
+                    if (!loaded && glContextAvailable)
+                        OnLoad(EventArgs.Empty);
+
+                    if (contextLost && glContextAvailable)
+                    {
+                        // we lost the gl context, we need to let the programmer
+                        // know so they can re-create textures etc.
+                        ContextSetInternal();
+                    }
+
+                }
+                else if (glSurfaceAvailable) // finish state if surface created, may take a frame or two until the android UI thread callbacks fire
+                {
+                    // trigger callbacks, must resume openAL device here
+                    OnResumeGameThread(this, EventArgs.Empty);
+
+                    // go to next state
+                    _internalState = InternalState.Running_GameThread;
+                }
+            }
+        }
+
+        void processStateExiting()
+        {
+            // go to next state
+            lock (_lockObject)
+            {
+                _internalState = InternalState.Exited_GameThread;
+            }
+        }
+
+        void processStateForceSurfaceRecreation()
+        {
+            // needed at app start
+            lock (_lockObject)
+            {
+                if (!androidSurfaceAvailable || !glContextAvailable)
+                {
+                    return;
+                }
+            }
+
+            DestroyGLSurface();
+            CreateGLSurface();
+
+            // go to next state
+            lock (_lockObject)
+            {
+                _internalState = InternalState.Running_GameThread;
+            }
+        }
+
+        // Return true to trigger worker thread pause
+        bool RunIteration(CancellationToken token)
+        {
+            // set main game thread global ID
+            Threading.ResetThread(Thread.CurrentThread.ManagedThreadId);
+
+            InternalState currentState = InternalState.Exited_GameThread;
+
+            lock (_lockObject)
+            {
+                currentState = _internalState;
+            }
+
+            switch (currentState)
+            {
+                // exit states
+                case InternalState.Exiting: // when ui thread wants to exit
+                    processStateExiting();
+                    break;
+
+                case InternalState.Exited_GameThread: // when game thread processed exiting event
+                    lock (_lockObject)
+                    {
+                        _waitForExitedStateProcessed.Set();
+                        cts.Cancel();
+                    }
+                    break;
+
+                // pause states
+                case InternalState.Pausing_UIThread: // when ui thread wants to pause              
+                    processStatePausing();
+                    break;
+
+                case InternalState.Paused_GameThread: // when game thread processed pausing event
+
+                    // this must be processed outside of this loop, in the new task thread!
+                    return true; // trigger pause of worker thread
+
+                // other states
+                case InternalState.Resuming_UIThread: // when ui thread wants to resume
+                    processStateResuming();
+
+                    // pause must wait for resume in case pause/resume is called in very quick succession
+                    lock (_lockObject)
+                    {
+                        _waitForResumedStateProcessed.Set();
+                    }
+                    break;
+
+                case InternalState.Running_GameThread: // when we are running game 
+                    processStateRunning(token);
+
+                    break;
+
+                case InternalState.ForceRecreateSurface:
+                    processStateForceSurfaceRecreation();
+                    break;
+
+                // default case, error
+                default:
+                    processStateDefault();
+                    cts.Cancel();
+                    break;
+            }
+
+            return false;
+        }
+
+        void UpdateFrameInternal(FrameEventArgs e)
+        {
+            OnUpdateFrame(e);
+            if (UpdateFrame != null)
+            {
+                UpdateFrame(this, e);
+            }
+
+        }
+
+        protected virtual void OnUpdateFrame(FrameEventArgs e)
+        {
+
+        }
+
+        // this method is called on the main thread
+        void UpdateAndRenderFrame()
+        {
+            curUpdateTime = DateTime.Now;
+            if (prevUpdateTime.Ticks != 0)
+            {
+                var t = (curUpdateTime - prevUpdateTime).TotalMilliseconds;
+                updateEventArgs.Time = t < 0 ? 0 : t;
+            }
+
+            try
+            {
+                UpdateFrameInternal(updateEventArgs);
+            }
+            catch (Content.ContentLoadException ex)
+            {
+                if (RenderOnUIThread)
+                    throw ex;
+                else
+                {
+                    Game.Activity.RunOnUiThread (() =>
+                    {
+                        throw ex;
+                    });
+                }
+            }
+
+            prevUpdateTime = curUpdateTime;
+
+            curRenderTime = DateTime.Now;
+            if (prevRenderTime.Ticks == 0)
+            {
+                var t = (curRenderTime - prevRenderTime).TotalMilliseconds;
+                renderEventArgs.Time = t < 0 ? 0 : t;
+            }
+
+            RenderFrameInternal(renderEventArgs);
+
+            prevRenderTime = curRenderTime;
+        }
+
+        void RenderFrameInternal(FrameEventArgs e)
+        {
+            if (LogFPS)
+            {
+                Mark();
+            }
+
+            OnRenderFrame(e);
+
+            if (RenderFrame != null)
+                RenderFrame(this, e);
+        }
+
+        protected virtual void OnRenderFrame(FrameEventArgs e)
+        {
+
+        }
+
+        int frames = 0;
+        double prev = 0;
+        double avgFps = 0;
+        double currentFps = 0;
+        double targetFps = 0;
+
+        void Mark()
+        {
+            double cur = stopWatch.Elapsed.TotalMilliseconds;
+            if (cur < 2000)
+            {
+                return;
+            }
+            frames++;
+
+            if (cur - prev >= 995)
+            {
+                avgFps = 0.8 * avgFps + 0.2 * frames;
+
+                Log.Verbose("AndroidGameView", "frames {0} elapsed {1}ms {2:F2} fps",
+                    frames,
+                    cur - prev,
+                    avgFps);
+
+                frames = 0;
+                prev = cur;
+            }
+        }
+
+        protected void EnsureUndisposed()
+        {
+            if (disposed)
+                throw new ObjectDisposedException("");
+        }
+
+        protected void DestroyGLContext()
+        {
+            if (eglContext != null)
+            {
+                if (!egl.EglDestroyContext(eglDisplay, eglContext))
+                    throw new Exception("Could not destroy EGL context" + GetErrorAsString());
+                eglContext = null;
+            }
+            if (eglDisplay != null)
+            {
+                if (!egl.EglTerminate(eglDisplay))
+                    throw new Exception("Could not terminate EGL connection" + GetErrorAsString());
+                eglDisplay = null;
+            }
+
+            glContextAvailable = false;
+        }
+
+        protected void DestroyGLSurface()
+        {
+            if (!(eglSurface == null || eglSurface == EGL10.EglNoSurface))
+            {
+                if (!egl.EglMakeCurrent(eglDisplay, EGL10.EglNoSurface,
+                        EGL10.EglNoSurface, EGL10.EglNoContext))
+                {
+                    Log.Verbose("AndroidGameView", "Could not unbind EGL surface" + GetErrorAsString());
+                }
+
+                if (!egl.EglDestroySurface(eglDisplay, eglSurface))
+                {
+                    Log.Verbose("AndroidGameView", "Could not destroy EGL surface" + GetErrorAsString());
+                }
+            }
+            eglSurface = null;
+            glSurfaceAvailable = false;
+
+        }
+
+        internal struct SurfaceConfig
+        {
+            public int Red;
+            public int Green;
+            public int Blue;
+            public int Alpha;
+            public int Depth;
+            public int Stencil;
+
+            public int[] ToConfigAttribs()
+            {
+                List<int> attribs = new List<int>();
+                if (Red != 0)
+                {
+                    attribs.Add(EGL11.EglRedSize);
+                    attribs.Add(Red);
+                }
+                if (Green != 0)
+                {
+                    attribs.Add(EGL11.EglGreenSize);
+                    attribs.Add(Green);
+                }
+                if (Blue != 0)
+                {
+                    attribs.Add(EGL11.EglBlueSize);
+                    attribs.Add(Blue);
+                }
+                if (Alpha != 0)
+                {
+                    attribs.Add(EGL11.EglAlphaSize);
+                    attribs.Add(Alpha);
+                }
+                if (Depth != 0)
+                {
+                    attribs.Add(EGL11.EglDepthSize);
+                    attribs.Add(Depth);
+                }
+                if (Stencil != 0)
+                {
+                    attribs.Add(EGL11.EglStencilSize);
+                    attribs.Add(Stencil);
+                }
+                attribs.Add(EGL11.EglRenderableType);
+                attribs.Add(4);
+                attribs.Add(EGL11.EglNone);
+
+                return attribs.ToArray();
+            }
+
+            static int GetAttribute(EGLConfig config, IEGL10 egl, EGLDisplay eglDisplay,int attribute)
+            {
+                int[] data = new int[1];
+                egl.EglGetConfigAttrib(eglDisplay, config, EGL11.EglRedSize, data);
+                return data[0];
+            }
+
+            public static SurfaceConfig FromEGLConfig (EGLConfig config, IEGL10 egl, EGLDisplay eglDisplay)
+            {
+                return new SurfaceConfig()
+                {
+                    Red = GetAttribute(config, egl, eglDisplay, EGL11.EglRedSize),
+                    Green = GetAttribute(config, egl, eglDisplay, EGL11.EglGreenSize),
+                    Blue = GetAttribute(config, egl, eglDisplay, EGL11.EglBlueSize),
+                    Alpha = GetAttribute(config, egl, eglDisplay, EGL11.EglAlphaSize),
+                    Depth = GetAttribute(config, egl, eglDisplay, EGL11.EglDepthSize),
+                    Stencil = GetAttribute(config, egl, eglDisplay, EGL11.EglStencilSize),
+                };
+            }
+
+            public override string ToString()
+            {
+                return string.Format("Red:{0} Green:{1} Blue:{2} Alpha:{3} Depth:{4} Stencil:{5}", Red, Green, Blue, Alpha, Depth, Stencil);
+            }
+        }
+
+        protected void CreateGLContext()
+        {
+            lostglContext = false;
+
+            egl = EGLContext.EGL.JavaCast<IEGL10>();
+
+            eglDisplay = egl.EglGetDisplay(EGL10.EglDefaultDisplay);
+            if (eglDisplay == EGL10.EglNoDisplay)
+                throw new Exception("Could not get EGL display" + GetErrorAsString());
+
+            int[] version = new int[2];
+            if (!egl.EglInitialize(eglDisplay, version))
+                throw new Exception("Could not initialize EGL display" + GetErrorAsString());
+
+            int depth = 0;
+            int stencil = 0;
+            switch (_game.graphicsDeviceManager.PreferredDepthStencilFormat)
+            {
+                case DepthFormat.Depth16:
+                    depth = 16;
+                    break;
+                case DepthFormat.Depth24:
+                    depth = 24;
+                    break;
+                case DepthFormat.Depth24Stencil8:
+                    depth = 24;
+                    stencil = 8;
+                    break;
+                case DepthFormat.None:
+                    break;
+            }
+
+            List<SurfaceConfig> configs = new List<SurfaceConfig>();
+            if (depth > 0)
+            {
+                configs.Add(new SurfaceConfig() { Red = 8, Green = 8, Blue = 8, Alpha = 8, Depth = depth, Stencil = stencil });
+                configs.Add(new SurfaceConfig() { Red = 5, Green = 6, Blue = 5, Depth = depth, Stencil = stencil });
+                configs.Add(new SurfaceConfig() { Depth = depth, Stencil = stencil });
+                if (depth > 16)
+                {
+                    configs.Add(new SurfaceConfig() { Red = 8, Green = 8, Blue = 8, Alpha = 8, Depth = 16 });
+                    configs.Add(new SurfaceConfig() { Red = 5, Green = 6, Blue = 5, Depth = 16 });
+                    configs.Add(new SurfaceConfig() { Depth = 16 });
+                }
+                configs.Add(new SurfaceConfig() { Red = 8, Green = 8, Blue = 8, Alpha = 8 });
+                configs.Add(new SurfaceConfig() { Red = 5, Green = 6, Blue = 5 });
+            }
+            else
+            {
+                configs.Add(new SurfaceConfig() { Red = 8, Green = 8, Blue = 8, Alpha = 8 });
+                configs.Add(new SurfaceConfig() { Red = 5, Green = 6, Blue = 5 });
+            }
+            configs.Add(new SurfaceConfig() { Red = 4, Green = 4, Blue = 4 });
+            int[] numConfigs = new int[1];
+            EGLConfig[] results = new EGLConfig[1];
+
+            if (!egl.EglGetConfigs(eglDisplay, null, 0, numConfigs)) {
+                throw new Exception("Could not get config count. " + GetErrorAsString());
+            }
+
+            EGLConfig[] cfgs = new EGLConfig[numConfigs[0]];
+            egl.EglGetConfigs(eglDisplay, cfgs, numConfigs[0], numConfigs);
+            Log.Verbose("AndroidGameView", "Device Supports");
+            foreach (var c in cfgs) {
+                Log.Verbose("AndroidGameView", string.Format(" {0}", SurfaceConfig.FromEGLConfig(c, egl, eglDisplay)));
+            }
+
+            bool found = false;
+            numConfigs[0] = 0;
+            foreach (var config in configs)
+            {
+                Log.Verbose("AndroidGameView", string.Format("Checking Config : {0}", config));
+                found = egl.EglChooseConfig(eglDisplay, config.ToConfigAttribs(), results, 1, numConfigs);
+                Log.Verbose("AndroidGameView", "EglChooseConfig returned {0} and {1}", found, numConfigs[0]);
+                if (!found || numConfigs[0] <= 0)
+                {
+                    Log.Verbose("AndroidGameView", "Config not supported");
+                    continue;
+                }
+                Log.Verbose("AndroidGameView", string.Format("Selected Config : {0}", config));
+                break;
+            }
+
+            if (!found || numConfigs[0] <= 0)
+                throw new Exception("No valid EGL configs found" + GetErrorAsString());
+            var createdVersion = new MonoGame.OpenGL.GLESVersion();
+            foreach (var v in MonoGame.OpenGL.GLESVersion.GetSupportedGLESVersions ()) {
+                Log.Verbose("AndroidGameView", "Creating GLES {0} Context", v);
+                eglContext = egl.EglCreateContext(eglDisplay, results[0], EGL10.EglNoContext, v.GetAttributes());
+                if (eglContext == null || eglContext == EGL10.EglNoContext)
+                {
+                    Log.Verbose("AndroidGameView", string.Format("GLES {0} Not Supported. {1}", v, GetErrorAsString()));
+                    eglContext = EGL10.EglNoContext;
+                    continue;
+                }
+                createdVersion = v;
+                break;
+            }
+            if (eglContext == null || eglContext == EGL10.EglNoContext)
+            {
+                eglContext = null;
+                throw new Exception("Could not create EGL context" + GetErrorAsString());
+            }
+            Log.Verbose("AndroidGameView", "Created GLES {0} Context", createdVersion);
+            eglConfig = results[0];
+            glContextAvailable = true;
+        }
+
+        private string GetErrorAsString()
+        {
+            switch (egl.EglGetError())
+            {
+                case EGL10.EglSuccess:
+                    return "Success";
+
+                case EGL10.EglNotInitialized:
+                    return "Not Initialized";
+
+                case EGL10.EglBadAccess:
+                    return "Bad Access";
+                case EGL10.EglBadAlloc:
+                    return "Bad Allocation";
+                case EGL10.EglBadAttribute:
+                    return "Bad Attribute";
+                case EGL10.EglBadConfig:
+                    return "Bad Config";
+                case EGL10.EglBadContext:
+                    return "Bad Context";
+                case EGL10.EglBadCurrentSurface:
+                    return "Bad Current Surface";
+                case EGL10.EglBadDisplay:
+                    return "Bad Display";
+                case EGL10.EglBadMatch:
+                    return "Bad Match";
+                case EGL10.EglBadNativePixmap:
+                    return "Bad Native Pixmap";
+                case EGL10.EglBadNativeWindow:
+                    return "Bad Native Window";
+                case EGL10.EglBadParameter:
+                    return "Bad Parameter";
+                case EGL10.EglBadSurface:
+                    return "Bad Surface";
+
+                default:
+                    return "Unknown Error";
+            }
+        }
+
+        protected void CreateGLSurface()
+        {
+            if (!glSurfaceAvailable)
+            {
+                try
+                {
+                    // If there is an existing surface, destroy the old one
+                    DestroyGLSurface();
+
+                    eglSurface = egl.EglCreateWindowSurface(eglDisplay, eglConfig, (Java.Lang.Object)this.Holder, null);
+                    if (eglSurface == null || eglSurface == EGL10.EglNoSurface)
+                        throw new Exception("Could not create EGL window surface" + GetErrorAsString());
+
+                    if (!egl.EglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext))
+                        throw new Exception("Could not make EGL current" + GetErrorAsString());
+
+                    glSurfaceAvailable = true;
+
+                    // Must set viewport after creation, the viewport has correct values in it already as we call it, but
+                    // the surface is created after the correct viewport is already applied so we must do it again.
+                    if (_game.GraphicsDevice != null)
+                        _game.graphicsDeviceManager.ResetClientBounds();
+
+                    if (MonoGame.OpenGL.GL.GetError == null)
+                        MonoGame.OpenGL.GL.LoadEntryPoints();
+                }
+                catch (Exception ex)
+                {
+                    Log.Error("AndroidGameView", ex.ToString());
+                    glSurfaceAvailable = false;
+                }
+            }
+        }
+
+        protected EGLSurface CreatePBufferSurface(EGLConfig config, int[] attribList)
+        {
+            IEGL10 egl = EGLContext.EGL.JavaCast<IEGL10>();
+            EGLSurface result = egl.EglCreatePbufferSurface(eglDisplay, config, attribList);
+            if (result == null || result == EGL10.EglNoSurface)
+                throw new Exception("EglCreatePBufferSurface");
+            return result;
+        }
+
+        protected void ContextSetInternal()
+        {
+            if (lostglContext)
+            {
+                if (_game.GraphicsDevice != null)
+                {
+                    _game.GraphicsDevice.Initialize();
+
+                    IsResuming = true;
+                    if (_gameWindow.Resumer != null)
+                    {
+                        _gameWindow.Resumer.LoadContent();
+                    }
+
+                    // Reload textures on a different thread so the resumer can be drawn
+                    System.Threading.Thread bgThread = new System.Threading.Thread(
+                        o =>
+                        {
+                            Android.Util.Log.Debug("MonoGame", "Begin reloading graphics content");
+                            Microsoft.Xna.Framework.Content.ContentManager.ReloadGraphicsContent();
+                            Android.Util.Log.Debug("MonoGame", "End reloading graphics content");
+
+                            // DeviceReset events
+                            _game.graphicsDeviceManager.OnDeviceReset(EventArgs.Empty);
+                            _game.GraphicsDevice.OnDeviceReset();
+
+                            IsResuming = false;
+                        });
+
+                    bgThread.Start();
+                }
+            }
+            OnContextSet(EventArgs.Empty);
+        }
+
+        protected void ContextLostInternal()
+        {
+            OnContextLost(EventArgs.Empty);
+            _game.graphicsDeviceManager.OnDeviceResetting(EventArgs.Empty);
+            if (_game.GraphicsDevice != null)
+                _game.GraphicsDevice.OnDeviceResetting();
+        }
+
+        protected virtual void OnContextLost(EventArgs eventArgs)
+        {
+
+        }
+
+        protected virtual void OnContextSet(EventArgs eventArgs)
+        {
+
+        }
+
+        protected virtual void OnUnload(EventArgs eventArgs)
+        {
+
+        }
+
+        protected virtual void OnLoad(EventArgs eventArgs)
+        {
+
+        }
+
+        protected virtual void OnStopped(EventArgs eventArgs)
+        {
+
+        }
+
+        #region Key and Motion
+
+        public override bool OnKeyDown(Keycode keyCode, KeyEvent e)
+        {
+            bool handled = false;
+            if (GamePad.OnKeyDown(keyCode, e))
+                return true;
+
+            handled = Keyboard.KeyDown(keyCode);
+#if !OUYA
+            // we need to handle the Back key here because it doesnt work any other way
+            if (keyCode == Keycode.Back)
+            {
+                GamePad.Back = true;
+                handled = true;
+            }
+#endif
+            if (keyCode == Keycode.VolumeUp)
+            {
+                AudioManager audioManager = (AudioManager)Context.GetSystemService(Context.AudioService);
+                audioManager.AdjustStreamVolume(Stream.Music, Adjust.Raise, VolumeNotificationFlags.ShowUi);
+                return true;
+            }
+
+            if (keyCode == Keycode.VolumeDown)
+            {
+                AudioManager audioManager = (AudioManager)Context.GetSystemService(Context.AudioService);
+                audioManager.AdjustStreamVolume(Stream.Music, Adjust.Lower, VolumeNotificationFlags.ShowUi);
+                return true;
+            }
+
+            return handled;
+        }
+
+        public override bool OnKeyUp(Keycode keyCode, KeyEvent e)
+        {
+            if (GamePad.OnKeyUp(keyCode, e))
+                return true;
+            return Keyboard.KeyUp(keyCode);
+        }
+
+        public override bool OnGenericMotionEvent(MotionEvent e)
+        {
+            if (GamePad.OnGenericMotionEvent(e))
+                return true;
+
+            return base.OnGenericMotionEvent(e);
+        }
+
+        #endregion
+
+        #region Properties
+
+        private IEGL10 egl;
+        private EGLDisplay eglDisplay;
+        private EGLConfig eglConfig;
+        private EGLContext eglContext;
+        private EGLSurface eglSurface;
+
+        /// <summary>The visibility of the window. Always returns true.</summary>
+        /// <value></value>
+        /// <exception cref="T:System.ObjectDisposed">The instance has been disposed</exception>
+        public virtual bool Visible
+        {
+            get
+            {
+                EnsureUndisposed();
+                return true;
+            }
+            set
+            {
+                EnsureUndisposed();
+            }
+        }
+
+        /// <summary>The size of the current view.</summary>
+        /// <value>A <see cref="T:System.Drawing.Size" /> which is the size of the current view.</value>
+        /// <exception cref="T:System.ObjectDisposed">The instance has been disposed</exception>
+        public virtual System.Drawing.Size Size
+        {
+            get
+            {
+                EnsureUndisposed();
+                return size;
+            }
+            set
+            {
+                EnsureUndisposed();
+                if (size != value)
+                {
+                    size = value;
+                    OnResize(EventArgs.Empty);
+                }
+            }
+        }
+
+        private void OnResize(EventArgs eventArgs)
+        {
+
+        }
+
+        #endregion
+
+        public event FrameEvent RenderFrame;
+        public event FrameEvent UpdateFrame;
+
+        public delegate void FrameEvent(object sender, FrameEventArgs e);
+
+        public class FrameEventArgs : EventArgs
+        {
+            double elapsed;
+
+            /// <summary>
+            /// Constructs a new FrameEventArgs instance.
+            /// </summary>
+            public FrameEventArgs()
+            {
+            }
+
+            /// <summary>
+            /// Constructs a new FrameEventArgs instance.
+            /// </summary>
+            /// <param name="elapsed">The amount of time that has elapsed since the previous event, in seconds.</param>
+            public FrameEventArgs(double elapsed)
+            {
+                Time = elapsed;
+            }
+
+            /// <summary>
+            /// Gets a <see cref="System.Double"/> that indicates how many seconds of time elapsed since the previous event.
+            /// </summary>
+            public double Time
+            {
+                get { return elapsed; }
+                internal set
+                {
+                    if (value < 0)
+                        throw new ArgumentOutOfRangeException();
+                    elapsed = value;
+                }
+            }
+        }
+
+        public BackgroundContext CreateBackgroundContext()
+        {
+            return new BackgroundContext(this);
+        }
+
+        public class BackgroundContext
+        {
+
+            EGLContext eglContext;
+            MonoGameAndroidGameView view;
+            EGLSurface surface;
+
+            public BackgroundContext(MonoGameAndroidGameView view)
+            {
+                this.view = view;
+                foreach (var v in MonoGame.OpenGL.GLESVersion.GetSupportedGLESVersions())
+                {
+                    eglContext = view.egl.EglCreateContext(view.eglDisplay, view.eglConfig, EGL10.EglNoContext, v.GetAttributes());
+                    if (eglContext == null || eglContext == EGL10.EglNoContext)
+                    {
+                        continue;
+                    }
+                    break;
+                }
+                if (eglContext == null || eglContext == EGL10.EglNoContext)
+                {
+                    eglContext = null;
+                    throw new Exception("Could not create EGL context" + view.GetErrorAsString());
+                }
+                int[] pbufferAttribList = new int[] { EGL10.EglWidth, 64, EGL10.EglHeight, 64, EGL10.EglNone };
+                surface = view.CreatePBufferSurface(view.eglConfig, pbufferAttribList);
+                if (surface == EGL10.EglNoSurface)
+                    throw new Exception("Could not create Pbuffer Surface" + view.GetErrorAsString());
+            }
+
+            public void MakeCurrent()
+            {
+                view.ClearCurrent();
+                view.egl.EglMakeCurrent(view.eglDisplay, surface, surface, eglContext);
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Android/OrientationListener.cs b/MonoGame.Framework/Android/OrientationListener.cs
new file mode 100644
index 00000000000..e465e555a18
--- /dev/null
+++ b/MonoGame.Framework/Android/OrientationListener.cs
@@ -0,0 +1,55 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using Android.App;
+using Android.Content;
+using Android.Hardware;
+using Android.Views;
+using Android.Provider;
+
+namespace Microsoft.Xna.Framework
+{
+    internal class OrientationListener : OrientationEventListener
+    {
+        /// <summary>
+        /// Constructor. SensorDelay.Ui is passed to the base class as this orientation listener 
+        /// is just used for flipping the screen orientation, therefore high frequency data is not required.
+        /// </summary>
+        public OrientationListener(Context context)
+            : base(context, SensorDelay.Ui)
+        {
+        }
+
+        public override void OnOrientationChanged(int orientation)
+        {
+            if (orientation == OrientationEventListener.OrientationUnknown)
+                return;
+
+            // Avoid changing orientation whilst the screen is locked
+            if (ScreenReceiver.ScreenLocked)
+                return;
+
+            // Check if screen orientation is locked by user: if it's locked, do not change orientation.
+            try
+            {
+                if (Settings.System.GetInt(Application.Context.ContentResolver, "accelerometer_rotation") == 0)
+                    return;
+            }
+            catch (Settings.SettingNotFoundException)
+            {
+                // Do nothing (or log warning?). In case android API or Xamarin do not support this Android system property.
+            }
+
+            var disporientation = AndroidCompatibility.GetAbsoluteOrientation(orientation);
+
+            // Only auto-rotate if target orientation is supported and not current
+            AndroidGameWindow gameWindow = (AndroidGameWindow)Game.Instance.Window;
+            if ((gameWindow.GetEffectiveSupportedOrientations() & disporientation) != 0 &&
+                disporientation != gameWindow.CurrentOrientation)
+            {
+                gameWindow.SetOrientation(disporientation, true);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Android/ResumeManager.cs b/MonoGame.Framework/Android/ResumeManager.cs
new file mode 100644
index 00000000000..7fb8d9d4bb0
--- /dev/null
+++ b/MonoGame.Framework/Android/ResumeManager.cs
@@ -0,0 +1,112 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2012 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// A default implementation of IResumeManager. Loads a user specified
+    /// image file (eg png) and draws it the middle of the screen.
+    /// 
+    /// Example usage in Game.Initialise():
+    /// 
+    /// #if ANDROID
+    ///    this.Window.SetResumer(new ResumeManager(this.Services, 
+    ///                                             spriteBatch, 
+    ///                                             "UI/ResumingTexture",
+    ///                                             1.0f, 0.01f));
+    /// #endif                                         
+    /// </summary>
+    public class ResumeManager : IResumeManager
+    {
+        ContentManager content;
+        GraphicsDevice device;
+        SpriteBatch spriteBatch;
+        string resumeTextureName;
+        Texture2D resumeTexture;
+        float rotation;
+        float scale;
+        float rotateSpeed;
+
+        public ResumeManager(IServiceProvider services,
+                             SpriteBatch spriteBatch,
+                             string resumeTextureName,
+                             float scale,
+                             float rotateSpeed)
+        {
+            this.content = new ContentManager(services, "Content");
+            this.device = ((IGraphicsDeviceService)services.GetService(typeof(IGraphicsDeviceService))).GraphicsDevice;
+            this.spriteBatch = spriteBatch;
+            this.resumeTextureName = resumeTextureName;
+            this.scale = scale;
+            this.rotateSpeed = rotateSpeed;
+        }
+
+        public virtual void LoadContent()
+        {
+            content.Unload();
+            resumeTexture = content.Load<Texture2D>(resumeTextureName);
+        }
+
+        public virtual void Draw()
+        {
+            rotation += rotateSpeed;
+
+            int sw = device.PresentationParameters.BackBufferWidth;
+            int sh = device.PresentationParameters.BackBufferHeight;
+            int tw = resumeTexture.Width;
+            int th = resumeTexture.Height;
+
+            // Draw the resume texture in the middle of the screen and make it spin
+            spriteBatch.Begin();
+            spriteBatch.Draw(resumeTexture,
+                            new Vector2(sw / 2, sh / 2), 
+                            null, Color.White, rotation,
+                            new Vector2(tw / 2, th / 2),
+                            scale, SpriteEffects.None, 0.0f);
+
+            spriteBatch.End();
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Android/ScreenReciever.cs b/MonoGame.Framework/Android/ScreenReciever.cs
new file mode 100644
index 00000000000..24832b8742b
--- /dev/null
+++ b/MonoGame.Framework/Android/ScreenReciever.cs
@@ -0,0 +1,51 @@
+using System;
+using Android.Content;
+using Microsoft.Xna.Framework.Media;
+using Android.App;
+
+namespace Microsoft.Xna.Framework
+{
+	internal class ScreenReceiver : BroadcastReceiver
+	{	
+		public static bool ScreenLocked;
+		
+		public override void OnReceive(Context context, Intent intent)
+		{
+			Android.Util.Log.Info("MonoGame", intent.Action.ToString());
+			if(intent.Action == Intent.ActionScreenOff)
+			{
+                OnLocked();
+			}
+			else if(intent.Action == Intent.ActionScreenOn)
+			{
+                // If the user turns the screen on just after it has automatically turned off, 
+                // the keyguard will not have had time to activate and the ActionUserPreset intent
+                // will not be broadcast. We need to check if the lock is currently active
+                // and if not re-enable the game related functions.
+                // http://stackoverflow.com/questions/4260794/how-to-tell-if-device-is-sleeping
+                KeyguardManager keyguard = (KeyguardManager)context.GetSystemService(Context.KeyguardService);
+                if (!keyguard.InKeyguardRestrictedInputMode())
+                    OnUnlocked();
+			}
+			else if(intent.Action == Intent.ActionUserPresent)
+			{
+                // This intent is broadcast when the user unlocks the phone
+                OnUnlocked();
+            }
+		}
+
+        private void OnLocked()
+        {
+            ScreenReceiver.ScreenLocked = true;
+            MediaPlayer.IsMuted = true;
+        }
+
+        private void OnUnlocked()
+        {
+            ScreenReceiver.ScreenLocked = false;
+            MediaPlayer.IsMuted = false;
+            ((AndroidGameWindow)Game.Instance.Window).GameView.Resume();
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/AudioChannels.cs b/MonoGame.Framework/Audio/AudioChannels.cs
new file mode 100644
index 00000000000..cb85d44e10a
--- /dev/null
+++ b/MonoGame.Framework/Audio/AudioChannels.cs
@@ -0,0 +1,20 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>
+    /// Represents how many channels are used in the audio data.
+    /// </summary>
+    public enum AudioChannels
+    {
+        /// <summary>Single channel.</summary> 
+        Mono = 1,
+        /// <summary>Two channels.</summary> 
+        Stereo = 2
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/AudioEmitter.cs b/MonoGame.Framework/Audio/AudioEmitter.cs
new file mode 100644
index 00000000000..70a79ed2065
--- /dev/null
+++ b/MonoGame.Framework/Audio/AudioEmitter.cs
@@ -0,0 +1,87 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>
+    /// Represents a 3D audio emitter. Used to simulate 3D audio effects.
+    /// </summary>
+	public class AudioEmitter
+	{
+        /// <summary>Initializes a new AudioEmitter instance.</summary>
+		public AudioEmitter ()
+		{
+            _dopplerScale = 1.0f;
+			Forward = Vector3.Forward;
+			Position = Vector3.Zero;
+			Up = Vector3.Up;
+			Velocity = Vector3.Zero;
+		}
+
+        private float _dopplerScale;
+
+        /// <summary>Gets or sets a scale applied to the Doppler effect between the AudioEmitter and an AudioListener.</summary>
+        /// <remarks>
+        /// <para>Defaults to 1.0</para>
+        /// <para>A value of 1.0 leaves the Doppler effect unmodified.</para>
+        /// </remarks>
+		public float DopplerScale 
+        {
+            get
+            {
+                return _dopplerScale;
+            }
+
+            set
+            {
+                if (value < 0.0f)
+                    throw new ArgumentOutOfRangeException("AudioEmitter.DopplerScale must be greater than or equal to 0.0f");
+
+                _dopplerScale = value;
+            }
+		}
+
+        /// <summary>Gets or sets the emitter's forward vector.</summary>
+        /// <remarks>
+        /// <para>Defaults to Vector3.Forward. (new Vector3(0, 0, -1))</para>
+        /// <para>Used with AudioListener.Velocity to calculate Doppler values.</para>
+        /// <para>The Forward and Up values must be orthonormal.</para>
+        /// </remarks>
+		public Vector3 Forward {
+			get;
+			set;
+		}
+
+        /// <summary>Gets or sets the position of this emitter.</summary>
+        public Vector3 Position {
+			get;
+			set;
+		}
+
+        /// <summary>Gets or sets the emitter's Up vector.</summary>
+        /// <remarks>
+        /// <para>Defaults to Vector3.Up. (new Vector3(0, -1, 1)).</para>
+        /// <para>The Up and Forward vectors must be orthonormal.</para>
+        /// </remarks>
+		public Vector3 Up {
+			get;
+			set;
+		}
+
+        /// <summary>Gets or sets the emitter's velocity vector.</summary>
+        /// <remarks>
+        /// <para>Defaults to Vector3.Zero.</para>
+        /// <para>This value is only used when calculating Doppler values.</para>
+        /// </remarks>
+		public Vector3 Velocity {
+			get;
+			set;
+		}
+
+	}
+}
diff --git a/MonoGame.Framework/Audio/AudioListener.cs b/MonoGame.Framework/Audio/AudioListener.cs
new file mode 100644
index 00000000000..efd1ee3adeb
--- /dev/null
+++ b/MonoGame.Framework/Audio/AudioListener.cs
@@ -0,0 +1,69 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>
+    /// Represents a 3D audio listener. Used when simulating 3D Audio.
+    /// </summary>
+	public class AudioListener
+	{
+		public AudioListener ()
+		{
+			Forward = Vector3.Forward;
+			Position = Vector3.Zero;
+			Up = Vector3.Up;
+			Velocity = Vector3.Zero;
+		}
+
+        /// <summary>Gets or sets the listener's forward vector.</summary>
+        /// <remarks>
+        /// <para>Defaults to Vector3.Forward. (new Vector3(0, 0, -1))</para>
+        /// <para>Used with AudioListener.Velocity and AudioEmitter.Velocity to calculate Doppler values.</para>
+        /// <para>The Forward and Up vectors must be orthonormal.</para>
+        /// </remarks>
+		public Vector3 Forward {
+			get;
+			set;
+		}
+
+        /// <summary>Gets or sets the listener's position.</summary>
+        /// <remarks>
+        /// Defaults to Vector3.Zero.
+        /// </remarks>
+		public Vector3 Position {
+			get;
+			set;
+		}
+
+        /// <summary>
+        /// Gets or sets the listener's up vector..
+        /// </summary>
+        /// <remarks>
+        /// <para>Defaults to Vector3.Up (New Vector3(0, -1, 0)).</para>
+        /// <para>Used with AudioListener.Velocity and AudioEmitter.Velocity to calculate Doppler values.</para>
+        /// <para>The values of the Forward and Up vectors must be orthonormal.</para>
+        /// </remarks>
+		public Vector3 Up {
+			get;
+			set;
+		}
+
+        /// <summary>Gets or sets the listener's velocity vector.</summary>
+        /// <remarks>
+        /// <para>Defaults to Vector3.Zero.</para>
+        /// <para>Scaled by DopplerScale to calculate the Doppler effect value applied to a Cue.</para>
+        /// <para>This value is only used to calculate Doppler values.</para>
+        /// </remarks>
+		public Vector3 Velocity {
+			get;
+			set;
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Audio/AudioLoader.cs b/MonoGame.Framework/Audio/AudioLoader.cs
new file mode 100644
index 00000000000..4b16d9f6095
--- /dev/null
+++ b/MonoGame.Framework/Audio/AudioLoader.cs
@@ -0,0 +1,648 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using MonoGame.OpenAL;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    internal static class AudioLoader
+    {
+        internal const int FormatPcm = 1;
+        internal const int FormatMsAdpcm = 2;
+        internal const int FormatIeee = 3;
+        internal const int FormatIma4 = 17;
+
+        public static ALFormat GetSoundFormat(int format, int channels, int bits)
+        {
+            switch (format)
+            {
+                case FormatPcm:
+                    // PCM
+                    switch (channels)
+                    {
+                        case 1: return bits == 8 ? ALFormat.Mono8 : ALFormat.Mono16;
+                        case 2: return bits == 8 ? ALFormat.Stereo8 : ALFormat.Stereo16;
+                        default: throw new NotSupportedException("The specified channel count is not supported.");
+                    }
+                case FormatMsAdpcm:
+                    // Microsoft ADPCM
+                    switch (channels)
+                    {
+                        case 1: return ALFormat.MonoMSAdpcm;
+                        case 2: return ALFormat.StereoMSAdpcm;
+                        default: throw new NotSupportedException("The specified channel count is not supported.");
+                    }
+                case FormatIeee:
+                    // IEEE Float
+                    switch (channels)
+                    {
+                        case 1: return ALFormat.MonoFloat32;
+                        case 2: return ALFormat.StereoFloat32;
+                        default: throw new NotSupportedException("The specified channel count is not supported.");
+                    }
+                case FormatIma4:
+                    // IMA4 ADPCM
+                    switch (channels)
+                    {
+                        case 1: return ALFormat.MonoIma4;
+                        case 2: return ALFormat.StereoIma4;
+                        default: throw new NotSupportedException("The specified channel count is not supported.");
+                    }
+                default:
+                    throw new NotSupportedException("The specified sound format (" + format.ToString() + ") is not supported.");
+            }
+        }
+
+        // Converts block alignment in bytes to sample alignment, primarily for compressed formats
+        // Calculation of sample alignment from http://kcat.strangesoft.net/openal-extensions/SOFT_block_alignment.txt
+        public static int SampleAlignment(ALFormat format, int blockAlignment)
+        {
+            switch (format)
+            {
+                case ALFormat.MonoIma4:
+                    return (blockAlignment - 4) / 4 * 8 + 1;
+                case ALFormat.StereoIma4:
+                    return (blockAlignment / 2 - 4) / 4 * 8 + 1;
+                case ALFormat.MonoMSAdpcm:
+                    return (blockAlignment - 7) * 2 + 2;
+                case ALFormat.StereoMSAdpcm:
+                    return (blockAlignment / 2 - 7) * 2 + 2;
+            }
+            return 0;
+        }
+
+        /// <summary>
+        /// Load a WAV file from stream.
+        /// </summary>
+        /// <param name="stream">The stream positioned at the start of the WAV file.</param>
+        /// <param name="format">Gets the OpenAL format enumeration value.</param>
+        /// <param name="frequency">Gets the frequency or sample rate.</param>
+        /// <param name="channels">Gets the number of channels.</param>
+        /// <param name="blockAlignment">Gets the block alignment, important for compressed sounds.</param>
+        /// <param name="bitsPerSample">Gets the number of bits per sample.</param>
+        /// <param name="samplesPerBlock">Gets the number of samples per block.</param>
+        /// <param name="sampleCount">Gets the total number of samples.</param>
+        /// <returns>The byte buffer containing the waveform data or compressed blocks.</returns>
+        public static byte[] Load(Stream stream, out ALFormat format, out int frequency, out int channels, out int blockAlignment, out int bitsPerSample, out int samplesPerBlock, out int sampleCount)
+        {
+            byte[] audioData = null;
+
+            using (BinaryReader reader = new BinaryReader(stream))
+            {
+                // for now we'll only support wave files
+                audioData = LoadWave(reader, out format, out frequency, out channels, out blockAlignment, out bitsPerSample, out samplesPerBlock, out sampleCount);
+            }
+
+            return audioData;
+        }
+
+        private static byte[] LoadWave(BinaryReader reader, out ALFormat format, out int frequency, out int channels, out int blockAlignment, out int bitsPerSample, out int samplesPerBlock, out int sampleCount)
+        {
+            byte[] audioData = null;
+
+            //header
+            string signature = new string(reader.ReadChars(4));
+            if (signature != "RIFF")
+                throw new ArgumentException("Specified stream is not a wave file.");
+            reader.ReadInt32(); // riff_chunk_size
+
+            string wformat = new string(reader.ReadChars(4));
+            if (wformat != "WAVE")
+                throw new ArgumentException("Specified stream is not a wave file.");
+
+            int audioFormat = 0;
+            channels = 0;
+            bitsPerSample = 0;
+            format = ALFormat.Mono16;
+            frequency = 0;
+            blockAlignment = 0;
+            samplesPerBlock = 0;
+            sampleCount = 0;
+
+            // WAVE header
+            while (audioData == null)
+            {
+                string chunkType = new string(reader.ReadChars(4));
+                int chunkSize = reader.ReadInt32();
+                switch (chunkType)
+                {
+                    case "fmt ":
+                        {
+                            audioFormat = reader.ReadInt16(); // 2
+                            channels = reader.ReadInt16(); // 4
+                            frequency = reader.ReadInt32();  // 8
+                            int byteRate = reader.ReadInt32();    // 12
+                            blockAlignment = (int)reader.ReadInt16();  // 14
+                            bitsPerSample = reader.ReadInt16(); // 16
+
+                            // Read extra data if present
+                            if (chunkSize > 16)
+                            {
+                                int extraDataSize = reader.ReadInt16();
+                                if (audioFormat == FormatIma4)
+                                {
+                                    samplesPerBlock = reader.ReadInt16();
+                                    extraDataSize -= 2;
+                                }
+                                if (extraDataSize > 0)
+                                {
+                                    if (reader.BaseStream.CanSeek)
+                                        reader.BaseStream.Seek(extraDataSize, SeekOrigin.Current);
+                                    else
+                                    {
+                                        for (int i = 0; i < extraDataSize; ++i)
+                                            reader.ReadByte();
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    case "fact":
+                        if (audioFormat == FormatIma4)
+                        {
+                            sampleCount = reader.ReadInt32() * channels;
+                            chunkSize -= 4;
+                        }
+                        // Skip any remaining chunk data
+                        if (chunkSize > 0)
+                        {
+                            if (reader.BaseStream.CanSeek)
+                                reader.BaseStream.Seek(chunkSize, SeekOrigin.Current);
+                            else
+                            {
+                                for (int i = 0; i < chunkSize; ++i)
+                                    reader.ReadByte();
+                            }
+                        }
+                        break;
+                    case "data":
+                        audioData = reader.ReadBytes(chunkSize);
+                        break;
+                    default:
+                        // Skip this chunk
+                        if (reader.BaseStream.CanSeek)
+                            reader.BaseStream.Seek(chunkSize, SeekOrigin.Current);
+                        else
+                        {
+                            for (int i = 0; i < chunkSize; ++i)
+                                reader.ReadByte();
+                        }
+                        break;
+                }
+            }
+
+            // Calculate fields we didn't read from the file
+            format = GetSoundFormat(audioFormat, channels, bitsPerSample);
+
+            if (samplesPerBlock == 0)
+            {
+                samplesPerBlock = SampleAlignment(format, blockAlignment);
+            }
+
+            if (sampleCount == 0)
+            {
+                switch (audioFormat)
+                {
+                    case FormatIma4:
+                    case FormatMsAdpcm:
+                        sampleCount = ((audioData.Length / blockAlignment) * samplesPerBlock) + SampleAlignment(format, audioData.Length % blockAlignment);
+                        break;
+                    case FormatPcm:
+                    case FormatIeee:
+                        sampleCount = audioData.Length / ((channels * bitsPerSample) / 8);
+                        break;
+                    default:
+                        throw new InvalidDataException("Unhandled WAV format " + format.ToString());
+                }
+            }
+
+            return audioData;
+        }
+
+        // Convert buffer containing 24-bit signed PCM wav data to a 16-bit signed PCM buffer
+        internal static unsafe byte[] Convert24To16(byte[] data, int offset, int count)
+        {
+            if ((offset + count > data.Length) || ((count % 3) != 0))
+                throw new ArgumentException("Invalid 24-bit PCM data received");
+            // Sample count includes both channels if stereo
+            var sampleCount = count / 3;
+            var outData = new byte[sampleCount * sizeof(short)];
+            fixed (byte* src = &data[offset])
+            {
+                fixed (byte* dst = &outData[0])
+                {
+                    var srcIndex = 0;
+                    var dstIndex = 0;
+                    for (int i = 0; i < sampleCount; ++i)
+                    {
+                        // Drop the least significant byte from the 24-bit sample to get the 16-bit sample
+                        dst[dstIndex] = src[srcIndex + 1];
+                        dst[dstIndex + 1] = src[srcIndex + 2];
+                        dstIndex += 2;
+                        srcIndex += 3;
+                    }
+                }
+            }
+            return outData;
+        }
+
+        // Convert buffer containing IEEE 32-bit float wav data to a 16-bit signed PCM buffer
+        internal static unsafe byte[] ConvertFloatTo16(byte[] data, int offset, int count)
+        {
+            if ((offset + count > data.Length) || ((count % 4) != 0))
+                throw new ArgumentException("Invalid 32-bit float PCM data received");
+            // Sample count includes both channels if stereo
+            var sampleCount = count / 4;
+            var outData = new byte[sampleCount * sizeof(short)];
+            fixed (byte* src = &data[offset])
+            {
+                float* f = (float*)src;
+                fixed (byte* dst = &outData[0])
+                {
+                    byte* d = dst;
+                    for (int i = 0; i < sampleCount; ++i)
+                    {
+                        short s = (short)(*f * 32767.0f);
+                        *d++ = (byte)(s & 0xff);
+                        *d++ = (byte)(s >> 8);
+                        ++f;
+                    }
+                }
+            }
+            return outData;
+        }
+
+        #region IMA4 decoding
+
+        // Step table
+        static int[] stepTable = new int[]
+        {
+            7, 8, 9, 10, 11, 12, 13, 14,
+            16, 17, 19, 21, 23, 25, 28, 31,
+            34, 37, 41, 45, 50, 55, 60, 66,
+            73, 80, 88, 97, 107, 118, 130, 143,
+            157, 173, 190, 209, 230, 253, 279, 307,
+            337, 371, 408, 449, 494, 544, 598, 658,
+            724, 796, 876, 963, 1060, 1166, 1282, 1411,
+            1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024,
+            3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484,
+            7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
+            15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794,
+            32767
+        };
+
+        // Step index tables
+        static int[] indexTable = new int[]
+        {
+            // ADPCM data size is 4
+            -1, -1, -1, -1, 2, 4, 6, 8,
+            -1, -1, -1, -1, 2, 4, 6, 8
+        };
+
+        struct ImaState
+        {
+            public int predictor;
+            public int stepIndex;
+        }
+
+        static int AdpcmImaWavExpandNibble(ref ImaState channel, int nibble)
+        {
+            int diff = stepTable[channel.stepIndex] >> 3;
+            if ((nibble & 0x04) != 0)
+                diff += stepTable[channel.stepIndex];
+            if ((nibble & 0x02) != 0)
+                diff += stepTable[channel.stepIndex] >> 1;
+            if ((nibble & 0x01) != 0)
+                diff += stepTable[channel.stepIndex] >> 2;
+            if ((nibble & 0x08) != 0)
+                channel.predictor -= diff;
+            else
+                channel.predictor += diff;
+
+            if (channel.predictor < -32768)
+                channel.predictor = -32768;
+            else if (channel.predictor > 32767)
+                channel.predictor = 32767;
+
+            channel.stepIndex += indexTable[nibble];
+
+            if (channel.stepIndex < 0)
+                channel.stepIndex = 0;
+            else if (channel.stepIndex > 88)
+                channel.stepIndex = 88;
+
+            return channel.predictor;
+        }
+
+        // Convert buffer containing IMA/ADPCM wav data to a 16-bit signed PCM buffer
+        internal static byte[] ConvertIma4ToPcm(byte[] buffer, int offset, int count, int channels, int blockAlignment)
+        {
+            ImaState channel0 = new ImaState();
+            ImaState channel1 = new ImaState();
+
+            int sampleCountFullBlock = ((blockAlignment / channels) - 4) / 4 * 8 + 1;
+            int sampleCountLastBlock = 0;
+            if ((count % blockAlignment) > 0)
+                sampleCountLastBlock = (((count % blockAlignment) / channels) - 4) / 4 * 8 + 1;
+            int sampleCount = ((count / blockAlignment) * sampleCountFullBlock) + sampleCountLastBlock;
+            var samples = new byte[sampleCount * sizeof(short) * channels];
+            int sampleOffset = 0;
+
+            while (count > 0)
+            {
+                int blockSize = blockAlignment;
+                if (count < blockSize)
+                    blockSize = count;
+                count -= blockAlignment;
+
+                channel0.predictor = buffer[offset++];
+                channel0.predictor |= buffer[offset++] << 8;
+                if ((channel0.predictor & 0x8000) != 0)
+                    channel0.predictor -= 0x10000;
+                channel0.stepIndex = buffer[offset++];
+                if (channel0.stepIndex > 88)
+                    channel0.stepIndex = 88;
+                offset++;
+                int index = sampleOffset * 2;
+                samples[index] = (byte)channel0.predictor;
+                samples[index + 1] = (byte)(channel0.predictor >> 8);
+                ++sampleOffset;
+
+                if (channels == 2)
+                {
+                    channel1.predictor = buffer[offset++];
+                    channel1.predictor |= buffer[offset++] << 8;
+                    if ((channel1.predictor & 0x8000) != 0)
+                        channel1.predictor -= 0x10000;
+                    channel1.stepIndex = buffer[offset++];
+                    if (channel1.stepIndex > 88)
+                        channel1.stepIndex = 88;
+                    offset++;
+                    index = sampleOffset * 2;
+                    samples[index] = (byte)channel1.predictor;
+                    samples[index + 1] = (byte)(channel1.predictor >> 8);
+                    ++sampleOffset;
+                }
+
+                if (channels == 2)
+                {
+                    for (int nibbles = 2 * (blockSize - 8); nibbles > 0; nibbles -= 16)
+                    {
+                        for (int i = 0; i < 4; i++)
+                        {
+                            index = (sampleOffset + i * 4) * 2;
+                            int sample = AdpcmImaWavExpandNibble(ref channel0, buffer[offset + i] & 0x0f);
+                            samples[index] = (byte)sample;
+                            samples[index + 1] = (byte)(sample >> 8);
+
+                            index = (sampleOffset + i * 4 + 2) * 2;
+                            sample = AdpcmImaWavExpandNibble(ref channel0, buffer[offset + i] >> 4);
+                            samples[index] = (byte)sample;
+                            samples[index + 1] = (byte)(sample >> 8);
+                        }
+                        offset += 4;
+
+                        for (int i = 0; i < 4; i++)
+                        {
+                            index = (sampleOffset + i * 4 + 1) * 2;
+                            int sample = AdpcmImaWavExpandNibble(ref channel1, buffer[offset + i] & 0x0f);
+                            samples[index] = (byte)sample;
+                            samples[index + 1] = (byte)(sample >> 8);
+
+                            index = (sampleOffset + i * 4 + 3) * 2;
+                            sample = AdpcmImaWavExpandNibble(ref channel1, buffer[offset + i] >> 4);
+                            samples[index] = (byte)sample;
+                            samples[index + 1] = (byte)(sample >> 8);
+                        }
+                        offset += 4;
+                        sampleOffset += 16;
+                    }
+                }
+                else
+                {
+                    for (int nibbles = 2 * (blockSize - 4); nibbles > 0; nibbles -= 2)
+                    {
+                        index = (sampleOffset * 2);
+                        int b = buffer[offset];
+                        int sample = AdpcmImaWavExpandNibble(ref channel0, b & 0x0f);
+                        samples[index] = (byte)sample;
+                        samples[index + 1] = (byte)(sample >> 8);
+                        index += 2;
+                        sample = AdpcmImaWavExpandNibble(ref channel0, b >> 4);
+                        samples[index] = (byte)sample;
+                        samples[index + 1] = (byte)(sample >> 8);
+
+                        sampleOffset += 2;
+                        ++offset;
+                    }
+                }
+            }
+
+            return samples;
+        }
+
+        #endregion
+
+        #region MS-ADPCM decoding
+
+        static int[] adaptationTable = new int[]
+        {
+            230, 230, 230, 230, 307, 409, 512, 614,
+            768, 614, 512, 409, 307, 230, 230, 230
+        };
+
+        static int[] adaptationCoeff1 = new int[]
+        {
+            256, 512, 0, 192, 240, 460, 392
+        };
+
+        static int[] adaptationCoeff2 = new int[]
+        {
+            0, -256, 0, 64, 0, -208, -232
+        };
+
+        struct MsAdpcmState
+        {
+            public int delta;
+            public int sample1;
+            public int sample2;
+            public int coeff1;
+            public int coeff2;
+        }
+
+        static int AdpcmMsExpandNibble(ref MsAdpcmState channel, int nibble)
+        {
+            int nibbleSign = nibble - (((nibble & 0x08) != 0) ? 0x10 : 0);
+            int predictor = ((channel.sample1 * channel.coeff1) + (channel.sample2 * channel.coeff2)) / 256 + (nibbleSign * channel.delta);
+
+            if (predictor < -32768)
+                predictor = -32768;
+            else if (predictor > 32767)
+                predictor = 32767;
+
+            channel.sample2 = channel.sample1;
+            channel.sample1 = predictor;
+
+            channel.delta = (adaptationTable[nibble] * channel.delta) / 256;
+            if (channel.delta < 16)
+                channel.delta = 16;
+
+            return predictor;
+        }
+
+        // Convert buffer containing MS-ADPCM wav data to a 16-bit signed PCM buffer
+        internal static byte[] ConvertMsAdpcmToPcm(byte[] buffer, int offset, int count, int channels, int blockAlignment)
+        {
+            MsAdpcmState channel0 = new MsAdpcmState();
+            MsAdpcmState channel1 = new MsAdpcmState();
+            int blockPredictor;
+
+            int sampleCountFullBlock = ((blockAlignment / channels) - 7) * 2 + 2;
+            int sampleCountLastBlock = 0;
+            if ((count % blockAlignment) > 0)
+                sampleCountLastBlock = (((count % blockAlignment) / channels) - 7) * 2 + 2;
+            int sampleCount = ((count / blockAlignment) * sampleCountFullBlock) + sampleCountLastBlock;
+            var samples = new byte[sampleCount * sizeof(short) * channels];
+            int sampleOffset = 0;
+
+            bool stereo = channels == 2;
+
+            while (count > 0)
+            {
+                int blockSize = blockAlignment;
+                if (count < blockSize)
+                    blockSize = count;
+                count -= blockAlignment;
+
+                int totalSamples = ((blockSize / channels) - 7) * 2 + 2;
+                if (totalSamples < 2)
+                    break;
+
+                int offsetStart = offset;
+                blockPredictor = buffer[offset];
+                ++offset;
+                if (blockPredictor > 6)
+                    blockPredictor = 6;
+                channel0.coeff1 = adaptationCoeff1[blockPredictor];
+                channel0.coeff2 = adaptationCoeff2[blockPredictor];
+                if (stereo)
+                {
+                    blockPredictor = buffer[offset];
+                    ++offset;
+                    if (blockPredictor > 6)
+                        blockPredictor = 6;
+                    channel1.coeff1 = adaptationCoeff1[blockPredictor];
+                    channel1.coeff2 = adaptationCoeff2[blockPredictor];
+                }
+
+                channel0.delta = buffer[offset];
+                channel0.delta |= buffer[offset + 1] << 8;
+                if ((channel0.delta & 0x8000) != 0)
+                    channel0.delta -= 0x10000;
+                offset += 2;
+                if (stereo)
+                {
+                    channel1.delta = buffer[offset];
+                    channel1.delta |= buffer[offset + 1] << 8;
+                    if ((channel1.delta & 0x8000) != 0)
+                        channel1.delta -= 0x10000;
+                    offset += 2;
+                }
+
+                channel0.sample1 = buffer[offset];
+                channel0.sample1 |= buffer[offset + 1] << 8;
+                if ((channel0.sample1 & 0x8000) != 0)
+                    channel0.sample1 -= 0x10000;
+                offset += 2;
+                if (stereo)
+                {
+                    channel1.sample1 = buffer[offset];
+                    channel1.sample1 |= buffer[offset + 1] << 8;
+                    if ((channel1.sample1 & 0x8000) != 0)
+                        channel1.sample1 -= 0x10000;
+                    offset += 2;
+                }
+
+                channel0.sample2 = buffer[offset];
+                channel0.sample2 |= buffer[offset + 1] << 8;
+                if ((channel0.sample2 & 0x8000) != 0)
+                    channel0.sample2 -= 0x10000;
+                offset += 2;
+                if (stereo)
+                {
+                    channel1.sample2 = buffer[offset];
+                    channel1.sample2 |= buffer[offset + 1] << 8;
+                    if ((channel1.sample2 & 0x8000) != 0)
+                        channel1.sample2 -= 0x10000;
+                    offset += 2;
+                }
+
+                if (stereo)
+                {
+                    samples[sampleOffset] = (byte)channel0.sample2;
+                    samples[sampleOffset + 1] = (byte)(channel0.sample2 >> 8);
+                    samples[sampleOffset + 2] = (byte)channel1.sample2;
+                    samples[sampleOffset + 3] = (byte)(channel1.sample2 >> 8);
+                    samples[sampleOffset + 4] = (byte)channel0.sample1;
+                    samples[sampleOffset + 5] = (byte)(channel0.sample1 >> 8);
+                    samples[sampleOffset + 6] = (byte)channel1.sample1;
+                    samples[sampleOffset + 7] = (byte)(channel1.sample1 >> 8);
+                    sampleOffset += 8;
+                }
+                else
+                {
+                    samples[sampleOffset] = (byte)channel0.sample2;
+                    samples[sampleOffset + 1] = (byte)(channel0.sample2 >> 8);
+                    samples[sampleOffset + 2] = (byte)channel0.sample1;
+                    samples[sampleOffset + 3] = (byte)(channel0.sample1 >> 8);
+                    sampleOffset += 4;
+                }
+
+                blockSize -= (offset - offsetStart);
+                if (stereo)
+                {
+                    for (int i = 0; i < blockSize; ++i)
+                    {
+                        int nibbles = buffer[offset];
+
+                        int sample = AdpcmMsExpandNibble(ref channel0, nibbles >> 4);
+                        samples[sampleOffset] = (byte)sample;
+                        samples[sampleOffset + 1] = (byte)(sample >> 8);
+
+                        sample = AdpcmMsExpandNibble(ref channel1, nibbles & 0x0f);
+                        samples[sampleOffset + 2] = (byte)sample;
+                        samples[sampleOffset + 3] = (byte)(sample >> 8);
+
+                        sampleOffset += 4;
+                        ++offset;
+                    }
+                }
+                else
+                {
+                    for (int i = 0; i < blockSize; ++i)
+                    {
+                        int nibbles = buffer[offset];
+
+                        int sample = AdpcmMsExpandNibble(ref channel0, nibbles >> 4);
+                        samples[sampleOffset] = (byte)sample;
+                        samples[sampleOffset + 1] = (byte)(sample >> 8);
+
+                        sample = AdpcmMsExpandNibble(ref channel0, nibbles & 0x0f);
+                        samples[sampleOffset + 2] = (byte)sample;
+                        samples[sampleOffset + 3] = (byte)(sample >> 8);
+
+                        sampleOffset += 4;
+                        ++offset;
+                    }
+                }
+            }
+
+            return samples;
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Audio/AudioUtil.cs b/MonoGame.Framework/Audio/AudioUtil.cs
new file mode 100644
index 00000000000..0672a828aea
--- /dev/null
+++ b/MonoGame.Framework/Audio/AudioUtil.cs
@@ -0,0 +1,43 @@
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    internal static class AudioUtil
+    {
+        /// <summary>
+        /// Takes WAV data and appends a header to it.
+        /// </summary>
+        internal static byte[] FormatWavData(byte[] buffer, int sampleRate, int channels)
+        {
+            //buffer should contain 16-bit PCM wave data
+            short bitsPerSample = 16;
+
+            using (var mStream = new MemoryStream(44+buffer.Length))
+            using (var writer = new BinaryWriter(mStream))
+            {
+                writer.Write("RIFF".ToCharArray()); //chunk id
+                writer.Write((int)(36 + buffer.Length)); //chunk size
+                writer.Write("WAVE".ToCharArray()); //RIFF type
+
+                writer.Write("fmt ".ToCharArray()); //chunk id
+                writer.Write((int)16); //format header size
+                writer.Write((short)1); //format (PCM)
+                writer.Write((short)channels);
+                writer.Write((int)sampleRate);
+                short blockAlign = (short)((bitsPerSample / 8) * (int)channels);
+                writer.Write((int)(sampleRate * blockAlign)); //byte rate
+                writer.Write((short)blockAlign);
+                writer.Write((short)bitsPerSample);
+
+                writer.Write("data".ToCharArray()); //chunk id
+                writer.Write((int)buffer.Length); //data size
+
+                writer.Write(buffer);
+                
+                return mStream.ToArray();
+            }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/DynamicSoundEffectInstance.OpenAL.cs b/MonoGame.Framework/Audio/DynamicSoundEffectInstance.OpenAL.cs
new file mode 100644
index 00000000000..9d6dcc5d1e6
--- /dev/null
+++ b/MonoGame.Framework/Audio/DynamicSoundEffectInstance.OpenAL.cs
@@ -0,0 +1,154 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using MonoGame.OpenAL;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    public sealed partial class DynamicSoundEffectInstance : SoundEffectInstance
+    {
+        private Queue<OALSoundBuffer> _queuedBuffers;
+        private ALFormat _format;
+
+        private void PlatformCreate()
+        {
+            _format = _channels == AudioChannels.Mono ? ALFormat.Mono16 : ALFormat.Stereo16;
+            InitializeSound();
+
+            SourceId = controller.ReserveSource();
+            HasSourceId = true;
+
+            _queuedBuffers = new Queue<OALSoundBuffer>();
+        }
+
+        private int PlatformGetPendingBufferCount()
+        {
+            return _queuedBuffers.Count;
+        }
+
+        private void PlatformPlay()
+        {
+            AL.GetError();
+
+            // Ensure that the source is not looped (due to source recycling)
+            AL.Source(SourceId, ALSourceb.Looping, false);
+            ALHelper.CheckError("Failed to set source loop state.");
+
+            AL.SourcePlay(SourceId);
+            ALHelper.CheckError("Failed to play the source.");
+        }
+
+        private void PlatformPause()
+        {
+            AL.GetError();
+            AL.SourcePause(SourceId);
+            ALHelper.CheckError("Failed to pause the source.");
+        }
+
+        private void PlatformResume()
+        {
+            AL.GetError();
+            AL.SourcePlay(SourceId);
+            ALHelper.CheckError("Failed to play the source.");
+        }
+
+        private void PlatformStop()
+        {
+            AL.GetError();
+            AL.SourceStop(SourceId);
+            ALHelper.CheckError("Failed to stop the source.");
+
+            // Remove all queued buffers
+            AL.Source(SourceId, ALSourcei.Buffer, 0);
+            while (_queuedBuffers.Count > 0)
+            {
+                var buffer = _queuedBuffers.Dequeue();
+                buffer.Dispose();
+            }
+        }
+
+        private void PlatformSubmitBuffer(byte[] buffer, int offset, int count)
+        {
+            // Get a buffer
+            OALSoundBuffer oalBuffer = new OALSoundBuffer();
+
+            // Bind the data
+            if (offset == 0)
+            {
+                oalBuffer.BindDataBuffer(buffer, _format, count, _sampleRate);
+            }
+            else
+            {
+                // BindDataBuffer does not support offset
+                var offsetBuffer = new byte[count];
+                Array.Copy(buffer, offset, offsetBuffer, 0, count);
+                oalBuffer.BindDataBuffer(offsetBuffer, _format, count, _sampleRate);
+            }
+
+            // Queue the buffer
+            AL.SourceQueueBuffer(SourceId, oalBuffer.OpenALDataBuffer);
+            ALHelper.CheckError();
+            _queuedBuffers.Enqueue(oalBuffer);
+
+            // If the source has run out of buffers, restart it
+            var sourceState = AL.GetSourceState(SourceId);
+            if (_state == SoundState.Playing && sourceState == ALSourceState.Stopped)
+            {
+                AL.SourcePlay(SourceId);
+                ALHelper.CheckError("Failed to resume source playback.");
+            }
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            // Stop the source and bind null buffer so that it can be recycled
+            AL.GetError();
+            if (AL.IsSource(SourceId))
+            {
+                AL.SourceStop(SourceId);
+                AL.Source(SourceId, ALSourcei.Buffer, 0);
+                ALHelper.CheckError("Failed to stop the source.");
+                controller.RecycleSource(SourceId);
+            }
+            
+            if (disposing)
+            {
+                while (_queuedBuffers.Count > 0)
+                {
+                    var buffer = _queuedBuffers.Dequeue();
+                    buffer.Dispose();
+                }
+
+                DynamicSoundEffectInstanceManager.RemoveInstance(this);
+            }
+        }
+
+        private void PlatformUpdateQueue()
+        {
+            // Get the completed buffers
+            AL.GetError();
+            int numBuffers;
+            AL.GetSource(SourceId, ALGetSourcei.BuffersProcessed, out numBuffers);
+            ALHelper.CheckError("Failed to get processed buffer count.");
+
+            // Unqueue them
+            if (numBuffers > 0)
+            {
+                AL.SourceUnqueueBuffers(SourceId, numBuffers);
+                ALHelper.CheckError("Failed to unqueue buffers.");
+                for (int i = 0; i < numBuffers; i++)
+                {
+                    var buffer = _queuedBuffers.Dequeue();
+                    buffer.Dispose();
+                }
+            }
+
+            // Raise the event for each removed buffer, if needed
+            for (int i = 0; i < numBuffers; i++)
+                CheckBufferCount();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Audio/DynamicSoundEffectInstance.Web.cs b/MonoGame.Framework/Audio/DynamicSoundEffectInstance.Web.cs
new file mode 100644
index 00000000000..f72119f068b
--- /dev/null
+++ b/MonoGame.Framework/Audio/DynamicSoundEffectInstance.Web.cs
@@ -0,0 +1,48 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    public sealed partial class DynamicSoundEffectInstance : SoundEffectInstance
+    {
+        private void PlatformCreate()
+        {
+        }
+
+        private int PlatformGetPendingBufferCount()
+        {
+            return 0;
+        }
+
+        private void PlatformPlay()
+        {
+        }
+
+        private void PlatformPause()
+        {
+        }
+
+        private void PlatformResume()
+        {
+        }
+
+        private void PlatformStop()
+        {
+        }
+
+        private void PlatformSubmitBuffer(byte[] buffer, int offset, int count)
+        {
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+        }
+
+        private void PlatformUpdateQueue()
+        {
+        }
+    }
+}
diff --git a/MonoGame.Framework/Audio/DynamicSoundEffectInstance.XAudio.cs b/MonoGame.Framework/Audio/DynamicSoundEffectInstance.XAudio.cs
new file mode 100644
index 00000000000..abf12226156
--- /dev/null
+++ b/MonoGame.Framework/Audio/DynamicSoundEffectInstance.XAudio.cs
@@ -0,0 +1,113 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using MonoGame.Utilities;
+using SharpDX;
+using SharpDX.Multimedia;
+using SharpDX.XAudio2;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    public sealed partial class DynamicSoundEffectInstance : SoundEffectInstance
+    {
+        private Queue<AudioBuffer> _queuedBuffers;
+        private Queue<byte[]> _pooledBuffers;
+        private static ByteBufferPool _bufferPool = new ByteBufferPool();
+
+        private void PlatformCreate()
+        {
+            _format = new WaveFormat(_sampleRate, (int)_channels);
+            _voice = new SourceVoice(SoundEffect.Device, _format, true);
+            _voice.BufferEnd += OnBufferEnd;
+            _queuedBuffers = new Queue<AudioBuffer>();
+            _pooledBuffers = new Queue<byte[]>();
+        }
+
+        private int PlatformGetPendingBufferCount()
+        {
+            return _queuedBuffers.Count;
+        }
+
+        private void PlatformPlay()
+        {
+            _voice.Start();
+        }
+
+        private void PlatformPause()
+        {
+            _voice.Stop();
+        }
+
+        private void PlatformResume()
+        {
+            _voice.Start();
+        }
+
+        private void PlatformStop()
+        {
+            _voice.Stop();
+
+            // Dequeue all the submitted buffers
+            _voice.FlushSourceBuffers();
+
+            while (_queuedBuffers.Count > 0)
+            {
+                var buffer = _queuedBuffers.Dequeue();
+                buffer.Stream.Dispose();
+                _bufferPool.Return(_pooledBuffers.Dequeue());
+            }
+        }
+
+        private void PlatformSubmitBuffer(byte[] buffer, int offset, int count)
+        {
+            // we need to copy so datastream does not pin the buffer that the user might modify later
+            byte[] pooledBuffer;
+            pooledBuffer = _bufferPool.Get(count);
+            _pooledBuffers.Enqueue(pooledBuffer);
+            Buffer.BlockCopy(buffer, offset, pooledBuffer, 0, count);
+
+            var stream = DataStream.Create(pooledBuffer, true, false, 0, true);
+            var audioBuffer = new AudioBuffer(stream);
+            audioBuffer.AudioBytes = count;
+
+            _voice.SubmitSourceBuffer(audioBuffer, null);
+            _queuedBuffers.Enqueue(audioBuffer);
+        }
+
+        private void PlatformUpdateQueue()
+        {
+            // The XAudio implementation utilizes callbacks, so no work here.
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            if (disposing)
+            {
+                while (_queuedBuffers.Count > 0)
+                {
+                    var buffer = _queuedBuffers.Dequeue();
+                    buffer.Stream.Dispose();
+                    _bufferPool.Return(_pooledBuffers.Dequeue());
+                }
+            }
+            // _voice is disposed by SoundEffectInstance.PlatformDispose
+        }
+
+        private void OnBufferEnd(IntPtr obj)
+        {
+            // Release the buffer
+            if (_queuedBuffers.Count > 0)
+            {
+                var buffer = _queuedBuffers.Dequeue();
+                buffer.Stream.Dispose();
+                _bufferPool.Return(_pooledBuffers.Dequeue());
+            }
+
+            CheckBufferCount();
+        }
+
+    }
+}
diff --git a/MonoGame.Framework/Audio/DynamicSoundEffectInstance.cs b/MonoGame.Framework/Audio/DynamicSoundEffectInstance.cs
new file mode 100644
index 00000000000..3899732722c
--- /dev/null
+++ b/MonoGame.Framework/Audio/DynamicSoundEffectInstance.cs
@@ -0,0 +1,312 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>
+    /// A <see cref="SoundEffectInstance"/> for which the audio buffer is provided by the game at run time.
+    /// </summary>
+    public sealed partial class DynamicSoundEffectInstance : SoundEffectInstance
+    {
+        #region Public Properties
+
+        /// <summary>
+        /// This value has no effect on DynamicSoundEffectInstance.
+        /// It may not be set.
+        /// </summary>
+        public override bool IsLooped
+        {
+            get
+            {
+                return false;
+            }
+
+            set
+            {
+                AssertNotDisposed();
+                if (value == true)
+                    throw new InvalidOperationException("IsLooped cannot be set true. Submit looped audio data to implement looping.");
+            }
+        }
+
+        public override SoundState State
+        {
+            get
+            {
+                AssertNotDisposed();
+                return _state;
+            }
+        }
+
+        /// <summary>
+        /// Returns the number of audio buffers queued for playback.
+        /// </summary>
+        public int PendingBufferCount
+        {
+            get
+            {
+                AssertNotDisposed();
+                return PlatformGetPendingBufferCount();
+            }
+        }
+
+        /// <summary>
+        /// The event that occurs when the number of queued audio buffers is less than or equal to 2.
+        /// </summary>
+        /// <remarks>
+        /// This event may occur when <see cref="Play()"/> is called or during playback when a buffer is completed.
+        /// </remarks>
+        public event EventHandler<EventArgs> BufferNeeded;
+
+        #endregion
+
+        private const int TargetPendingBufferCount = 3;
+        private int _buffersNeeded;
+        private int _sampleRate;
+        private AudioChannels _channels;
+        private SoundState _state;
+
+        #region Public Constructor
+
+        /// <param name="sampleRate">Sample rate, in Hertz (Hz).</param>
+        /// <param name="channels">Number of channels (mono or stereo).</param>
+        public DynamicSoundEffectInstance(int sampleRate, AudioChannels channels)
+        {
+            SoundEffect.Initialize();
+            if (SoundEffect._systemState != SoundEffect.SoundSystemState.Initialized)
+                throw new NoAudioHardwareException("Audio has failed to initialize. Call SoundEffect.Initialize() before sound operation to get more specific errors.");
+
+            if ((sampleRate < 8000) || (sampleRate > 48000))
+                throw new ArgumentOutOfRangeException("sampleRate");
+            if ((channels != AudioChannels.Mono) && (channels != AudioChannels.Stereo))
+                throw new ArgumentOutOfRangeException("channels");
+
+            _sampleRate = sampleRate;
+            _channels = channels;
+            _state = SoundState.Stopped;
+            PlatformCreate();
+            
+            // This instance is added to the pool so that its volume reflects master volume changes
+            // and it contributes to the playing instances limit, but the source/voice is not owned by the pool.
+            _isPooled = false;
+            _isDynamic = true;
+        }
+
+        #endregion
+
+        #region Public Functions
+
+        /// <summary>
+        /// Returns the duration of an audio buffer of the specified size, based on the settings of this instance.
+        /// </summary>
+        /// <param name="sizeInBytes">Size of the buffer, in bytes.</param>
+        /// <returns>The playback length of the buffer.</returns>
+        public TimeSpan GetSampleDuration(int sizeInBytes)
+        {
+            AssertNotDisposed();
+            return SoundEffect.GetSampleDuration(sizeInBytes, _sampleRate, _channels);
+        }
+
+        /// <summary>
+        /// Returns the size, in bytes, of a buffer of the specified duration, based on the settings of this instance.
+        /// </summary>
+        /// <param name="duration">The playback length of the buffer.</param>
+        /// <returns>The data size of the buffer, in bytes.</returns>
+        public int GetSampleSizeInBytes(TimeSpan duration)
+        {
+            AssertNotDisposed();
+            return SoundEffect.GetSampleSizeInBytes(duration, _sampleRate, _channels);
+        }
+
+        /// <summary>
+        /// Plays or resumes the DynamicSoundEffectInstance.
+        /// </summary>
+        public override void Play()
+        {
+            AssertNotDisposed();
+
+            if (_state != SoundState.Playing)
+            {
+                // Ensure that the volume reflects master volume, which is done by the setter.
+                Volume = Volume;
+
+                // Add the instance to the pool
+                if (!SoundEffectInstancePool.SoundsAvailable)
+                    throw new InstancePlayLimitException();
+                SoundEffectInstancePool.Remove(this);
+
+                PlatformPlay();
+                _state = SoundState.Playing;
+
+                CheckBufferCount();
+                DynamicSoundEffectInstanceManager.AddInstance(this);
+            }
+        }
+
+        /// <summary>
+        /// Pauses playback of the DynamicSoundEffectInstance.
+        /// </summary>
+        public override void Pause()
+        {
+            AssertNotDisposed();
+            PlatformPause();
+            _state = SoundState.Paused;
+        }
+
+        /// <summary>
+        /// Resumes playback of the DynamicSoundEffectInstance.
+        /// </summary>
+        public override void Resume()
+        {
+            AssertNotDisposed();
+
+            if (_state != SoundState.Playing)
+            {
+                Volume = Volume;
+
+                // Add the instance to the pool
+                if (!SoundEffectInstancePool.SoundsAvailable)
+                    throw new InstancePlayLimitException();
+                SoundEffectInstancePool.Remove(this);
+            }
+
+            PlatformResume();
+            _state = SoundState.Playing;
+        }
+
+        /// <summary>
+        /// Immediately stops playing the DynamicSoundEffectInstance.
+        /// </summary>
+        /// <remarks>
+        /// Calling this also releases all queued buffers.
+        /// </remarks>
+        public override void Stop()
+        {
+            Stop(true);
+        }
+
+        /// <summary>
+        /// Stops playing the DynamicSoundEffectInstance.
+        /// If the <paramref name="immediate"/> parameter is false, this call has no effect.
+        /// </summary>
+        /// <remarks>
+        /// Calling this also releases all queued buffers.
+        /// </remarks>
+        /// <param name="immediate">When set to false, this call has no effect.</param>
+        public override void Stop(bool immediate)
+        {
+            AssertNotDisposed();
+            
+            if (immediate)
+            {
+                DynamicSoundEffectInstanceManager.RemoveInstance(this);
+
+                PlatformStop();
+                _state = SoundState.Stopped;
+
+                SoundEffectInstancePool.Add(this);
+            }
+        }
+
+        /// <summary>
+        /// Queues an audio buffer for playback.
+        /// </summary>
+        /// <remarks>
+        /// The buffer length must conform to alignment requirements for the audio format.
+        /// </remarks>
+        /// <param name="buffer">The buffer containing PCM audio data.</param>
+        public void SubmitBuffer(byte[] buffer)
+        {
+            AssertNotDisposed();
+            
+            if (buffer.Length == 0)
+                throw new ArgumentException("Buffer may not be empty.");
+
+            // Ensure that the buffer length matches alignment.
+            // The data must be 16-bit, so the length is a multiple of 2 (mono) or 4 (stereo).
+            var sampleSize = 2 * (int)_channels;
+            if (buffer.Length % sampleSize != 0)
+                throw new ArgumentException("Buffer length does not match format alignment.");
+
+            SubmitBuffer(buffer, 0, buffer.Length);
+        }
+
+        /// <summary>
+        /// Queues an audio buffer for playback.
+        /// </summary>
+        /// <remarks>
+        /// The buffer length must conform to alignment requirements for the audio format.
+        /// </remarks>
+        /// <param name="buffer">The buffer containing PCM audio data.</param>
+        /// <param name="offset">The starting position of audio data.</param>
+        /// <param name="count">The amount of bytes to use.</param>
+        public void SubmitBuffer(byte[] buffer, int offset, int count)
+        {
+            AssertNotDisposed();
+            
+            if ((buffer == null) || (buffer.Length == 0))
+                throw new ArgumentException("Buffer may not be null or empty.");
+            if (count <= 0)
+                throw new ArgumentException("Number of bytes must be greater than zero.");
+            if ((offset + count) > buffer.Length)
+                throw new ArgumentException("Buffer is shorter than the specified number of bytes from the offset.");
+
+            // Ensure that the buffer length and start position match alignment.
+            var sampleSize = 2 * (int)_channels;
+            if (count % sampleSize != 0)
+                throw new ArgumentException("Number of bytes does not match format alignment.");
+            if (offset % sampleSize != 0)
+                throw new ArgumentException("Offset into the buffer does not match format alignment.");
+
+            PlatformSubmitBuffer(buffer, offset, count);
+        }
+
+        #endregion
+
+        #region Nonpublic Functions
+
+        private void AssertNotDisposed()
+        {
+            if (IsDisposed)
+                throw new ObjectDisposedException(null);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            PlatformDispose(disposing);
+            base.Dispose(disposing);
+        }
+
+        private void CheckBufferCount()
+        {
+            if ((PendingBufferCount < TargetPendingBufferCount) && (_state == SoundState.Playing))
+                _buffersNeeded++;
+        }
+
+        internal void UpdateQueue()
+        {
+            // Update the buffers
+            PlatformUpdateQueue();
+
+            // Raise the event
+            var bufferNeededHandler = BufferNeeded;
+
+            if (bufferNeededHandler != null)
+            {
+                var eventCount = (_buffersNeeded < 3) ? _buffersNeeded : 3;
+                for (var i = 0; i < eventCount; i++)
+                {
+                    bufferNeededHandler(this, EventArgs.Empty);
+                }
+            }
+
+            _buffersNeeded = 0;
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Audio/DynamicSoundEffectInstanceManager.cs b/MonoGame.Framework/Audio/DynamicSoundEffectInstanceManager.cs
new file mode 100644
index 00000000000..89d8f38371b
--- /dev/null
+++ b/MonoGame.Framework/Audio/DynamicSoundEffectInstanceManager.cs
@@ -0,0 +1,64 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>
+    /// Handles the buffer events of all DynamicSoundEffectInstance instances.
+    /// </summary>
+    internal static class DynamicSoundEffectInstanceManager
+    {
+        private static readonly List<WeakReference> _playingInstances;
+
+        static DynamicSoundEffectInstanceManager()
+        {
+            _playingInstances = new List<WeakReference>();
+        }
+
+        public static void AddInstance(DynamicSoundEffectInstance instance)
+        {
+            var weakRef = new WeakReference(instance);
+            _playingInstances.Add(weakRef);
+        }
+
+        public static void RemoveInstance(DynamicSoundEffectInstance instance)
+        {
+            for (int i = _playingInstances.Count - 1; i >= 0; i--)
+            {
+                if (_playingInstances[i].Target == instance)
+                {
+                    _playingInstances.RemoveAt(i);
+                    return;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Updates buffer queues of the currently playing instances.
+        /// </summary>
+        /// <remarks>
+        /// XNA posts <see cref="DynamicSoundEffectInstance.BufferNeeded"/> events always on the main thread.
+        /// </remarks>
+        public static void UpdatePlayingInstances()
+        {
+            for (int i = _playingInstances.Count - 1; i >= 0; i--)
+            {
+                var target = _playingInstances[i].Target as DynamicSoundEffectInstance;
+                if (target != null)
+                {
+                    if (!target.IsDisposed)
+                        target.UpdateQueue();
+                }
+                else
+                {
+                    // The instance has been disposed.
+                    _playingInstances.RemoveAt(i);
+                }
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Audio/InstancePlayLimitException.cs b/MonoGame.Framework/Audio/InstancePlayLimitException.cs
new file mode 100644
index 00000000000..06b42d27380
--- /dev/null
+++ b/MonoGame.Framework/Audio/InstancePlayLimitException.cs
@@ -0,0 +1,26 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>
+    /// The exception thrown when the system attempts to play more SoundEffectInstances than allotted.
+    /// </summary>
+    /// <remarks>
+    /// Most platforms have a hard limit on how many sounds can be played simultaneously. This exception is thrown when that limit is exceeded.
+    /// </remarks>
+    [DataContract]
+#if WINDOWS_UAP
+    public sealed class InstancePlayLimitException : Exception
+#else
+    public sealed class InstancePlayLimitException : ExternalException
+#endif
+	{
+	}
+}
+
diff --git a/MonoGame.Framework/Audio/Microphone.Default.cs b/MonoGame.Framework/Audio/Microphone.Default.cs
new file mode 100644
index 00000000000..38d1907f843
--- /dev/null
+++ b/MonoGame.Framework/Audio/Microphone.Default.cs
@@ -0,0 +1,35 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>
+    /// Provides microphones capture features. 
+    /// </summary>	
+    public sealed partial class Microphone
+    {
+        internal void PlatformStart()
+        {
+			throw new NotImplementedException();
+        }
+
+        internal void PlatformStop()
+        {
+			throw new NotImplementedException();
+        }
+		
+		internal void Update()
+		{
+			throw new NotImplementedException();
+		}
+		
+		internal int PlatformGetData(byte[] buffer, int offset, int count)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Audio/Microphone.OpenAL.cs b/MonoGame.Framework/Audio/Microphone.OpenAL.cs
new file mode 100644
index 00000000000..5e1b21c7011
--- /dev/null
+++ b/MonoGame.Framework/Audio/Microphone.OpenAL.cs
@@ -0,0 +1,165 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using MonoGame.Utilities;
+
+#if OPENAL
+using MonoGame.OpenAL;
+#if IOS || MONOMAC
+using AudioToolbox;
+using AudioUnit;
+using AVFoundation;
+#endif
+#endif
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>
+    /// Provides microphones capture features.  
+    /// </summary>
+    public sealed partial class Microphone
+    {
+        private IntPtr _captureDevice = IntPtr.Zero;
+
+        internal void CheckALCError(string operation)
+        {
+            AlcError error = Alc.GetErrorForDevice(_captureDevice);
+
+            if (error == AlcError.NoError)
+                return;
+
+            string errorFmt = "OpenAL Error: {0}";
+
+            throw new NoMicrophoneConnectedException(String.Format("{0} - {1}",
+                            operation,
+                            string.Format(errorFmt, error)));
+        }
+       
+        internal static void PopulateCaptureDevices()
+        {
+            // clear microphones
+            if (_allMicrophones != null)
+                _allMicrophones.Clear();
+            else
+                _allMicrophones = new List<Microphone>();
+
+            _default = null;
+
+            // default device
+            string defaultDevice = Alc.GetString(IntPtr.Zero, AlcGetString.CaptureDefaultDeviceSpecifier);
+
+#if true //DESKTOPGL
+            // enumerating capture devices
+            IntPtr deviceList = Alc.alcGetString(IntPtr.Zero, (int)AlcGetString.CaptureDeviceSpecifier);
+
+            // Marshal native UTF-8 character array to .NET string
+            // The native string is a null-char separated list of known capture device specifiers ending with an empty string
+
+            while (true)
+            {  
+                var deviceIdentifier = InteropHelpers.Utf8ToString(deviceList);
+
+                if (string.IsNullOrEmpty(deviceIdentifier))
+                    break;
+
+                var microphone = new Microphone(deviceIdentifier);
+                _allMicrophones.Add(microphone);
+                if (deviceIdentifier == defaultDevice)
+                    _default = microphone;
+
+                // increase the offset, add one extra for the terminator
+                deviceList += deviceIdentifier.Length + 1;
+            }
+#else
+            // Xamarin platforms don't provide an handle to alGetString that allow to marshal string arrays
+            // so we're basically only adding the default microphone
+            Microphone microphone = new Microphone(defaultDevice);
+            _allMicrophones.Add(microphone);
+            _default = microphone;
+#endif
+        }
+
+        internal void PlatformStart()
+        {
+            if (_state == MicrophoneState.Started)
+                return;
+
+            _captureDevice = Alc.CaptureOpenDevice(
+                Name,
+                (uint)_sampleRate,
+                ALFormat.Mono16,
+                GetSampleSizeInBytes(_bufferDuration));
+
+            CheckALCError("Failed to open capture device.");
+
+            if (_captureDevice != IntPtr.Zero)
+            {
+                Alc.CaptureStart(_captureDevice);
+                CheckALCError("Failed to start capture.");
+
+                _state = MicrophoneState.Started;
+            }
+			else
+            {
+                throw new NoMicrophoneConnectedException("Failed to open capture device.");
+            }
+        }
+
+        internal void PlatformStop()
+        {
+            if (_state == MicrophoneState.Started)
+            {
+                Alc.CaptureStop(_captureDevice);
+                CheckALCError("Failed to stop capture.");
+                Alc.CaptureCloseDevice(_captureDevice);
+                CheckALCError("Failed to close capture device.");
+                _captureDevice = IntPtr.Zero;
+            }
+            _state = MicrophoneState.Stopped;
+        }
+
+        internal int GetQueuedSampleCount()
+        {
+            if (_state == MicrophoneState.Stopped || BufferReady == null)
+                return 0;
+
+            int[] values = new int[1];
+            Alc.GetInteger(_captureDevice, AlcGetInteger.CaptureSamples, 1, values);
+
+            CheckALCError("Failed to query capture samples.");
+
+            return values[0];
+        }
+
+        internal void Update()
+        {
+            if (GetQueuedSampleCount() > 0)
+            {
+                BufferReady.Invoke(this, EventArgs.Empty);                
+            }
+        }
+
+        internal int PlatformGetData(byte[] buffer, int offset, int count)
+        {
+            int sampleCount = GetQueuedSampleCount();
+            sampleCount = Math.Min(count / 2, sampleCount); // 16bit adjust
+
+            if (sampleCount > 0)
+            {
+                GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+                Alc.CaptureSamples(_captureDevice, handle.AddrOfPinnedObject() + offset, sampleCount);
+                handle.Free();
+
+                CheckALCError("Failed to capture samples.");
+
+                return sampleCount * 2; // 16bit adjust
+            }
+
+            return 0;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Audio/Microphone.cs b/MonoGame.Framework/Audio/Microphone.cs
new file mode 100644
index 00000000000..0e31926ffea
--- /dev/null
+++ b/MonoGame.Framework/Audio/Microphone.cs
@@ -0,0 +1,232 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>
+    /// Microphone state. 
+    /// </summary>
+    public enum MicrophoneState
+    {
+        Started,
+        Stopped
+    }
+
+    /// <summary>
+    /// Provides microphones capture features. 
+    /// </summary>
+    public sealed partial class Microphone
+    {
+        #region Internal Constructors
+
+        internal Microphone()
+        {
+
+        }
+
+        internal Microphone(string name)
+        {
+            Name = name;
+        }
+
+        #endregion
+
+        #region Public Fields
+
+        /// <summary>
+        /// Returns the friendly name of the microphone.
+        /// </summary>
+        public readonly string Name;
+
+        #endregion
+
+        #region Public Properties
+
+        private TimeSpan _bufferDuration = TimeSpan.FromMilliseconds(1000.0);
+
+        /// <summary>
+        /// Gets or sets the capture buffer duration. This value must be greater than 100 milliseconds, lower than 1000 milliseconds, and must be 10 milliseconds aligned (BufferDuration % 10 == 10).
+        /// </summary>
+        public TimeSpan BufferDuration
+        {
+            get { return _bufferDuration; }
+            set
+            {
+                if (value.TotalMilliseconds < 100 || value.TotalMilliseconds > 1000)
+                    throw new ArgumentOutOfRangeException("Buffer duration must be a value between 100 and 1000 milliseconds.");
+                if (value.TotalMilliseconds % 10 != 0)
+                    throw new ArgumentOutOfRangeException("Buffer duration must be 10ms aligned (BufferDuration % 10 == 0)");
+                _bufferDuration = value;
+            }
+        }
+
+        // always true on mobile, this can't be queried on any platform (it was most probably only set to true if the headset was plugged in an XInput controller)
+#if IOS || ANDROID
+        private const bool _isHeadset = true;
+#else
+        private const bool _isHeadset = false;
+#endif
+        /// <summary>
+        /// Determines if the microphone is a wired headset.
+        /// Note: XNA could know if a headset microphone was plugged in an Xbox 360 controller but MonoGame can't.
+        /// Hence, this is always true on mobile platforms, and always false otherwise.
+        /// </summary>
+        public bool IsHeadset
+        {
+            get { return _isHeadset; }
+        }
+
+        private int _sampleRate = 44100; // XNA default is 44100, don't know if it supports any other rates
+
+        /// <summary>
+        /// Returns the sample rate of the captured audio.
+        /// Note: default value is 44100hz
+        /// </summary>
+        public int SampleRate
+        {
+            get { return _sampleRate; }
+        }
+
+        private MicrophoneState _state = MicrophoneState.Stopped;
+
+        /// <summary>
+        /// Returns the state of the Microphone. 
+        /// </summary>
+        public MicrophoneState State
+        {
+            get { return _state; }
+        }
+
+        #endregion
+
+        #region Static Members
+
+        private static List<Microphone> _allMicrophones = null;
+
+        /// <summary>
+        /// Returns all compatible microphones.
+        /// </summary>
+        public static ReadOnlyCollection<Microphone> All
+        {
+            get
+            {
+                SoundEffect.Initialize();                
+                if (_allMicrophones == null)
+                    _allMicrophones = new List<Microphone>();
+                return new ReadOnlyCollection<Microphone>(_allMicrophones);
+            }
+        }
+
+        private static Microphone _default = null;
+
+        /// <summary>
+        /// Returns the default microphone.
+        /// </summary>
+        public static Microphone Default
+        {
+            get { SoundEffect.Initialize(); return _default; }
+        }       
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Returns the duration based on the size of the buffer (assuming 16-bit PCM data).
+        /// </summary>
+        /// <param name="sizeInBytes">Size, in bytes</param>
+        /// <returns>TimeSpan of the duration.</returns>
+        public TimeSpan GetSampleDuration(int sizeInBytes)
+        {
+            // this should be 10ms aligned
+            // this assumes 16bit mono data
+            return SoundEffect.GetSampleDuration(sizeInBytes, _sampleRate, AudioChannels.Mono);
+        }
+
+        /// <summary>
+        /// Returns the size, in bytes, of the array required to hold the specified duration of 16-bit PCM data. 
+        /// </summary>
+        /// <param name="duration">TimeSpan of the duration of the sample.</param>
+        /// <returns>Size, in bytes, of the buffer.</returns>
+        public int GetSampleSizeInBytes(TimeSpan duration)
+        {
+            // this should be 10ms aligned
+            // this assumes 16bit mono data
+            return SoundEffect.GetSampleSizeInBytes(duration, _sampleRate, AudioChannels.Mono);
+        }
+
+        /// <summary>
+        /// Starts microphone capture.
+        /// </summary>
+        public void Start()
+        {
+            PlatformStart();
+        }
+
+        /// <summary>
+        /// Stops microphone capture.
+        /// </summary>
+        public void Stop()
+        {
+            PlatformStop();
+        }
+
+        /// <summary>
+        /// Gets the latest available data from the microphone.
+        /// </summary>
+        /// <param name="buffer">Buffer, in bytes, of the captured data (16-bit PCM).</param>
+        /// <returns>The buffer size, in bytes, of the captured data.</returns>
+        public int GetData(byte[] buffer)
+        {
+            return GetData(buffer, 0, buffer.Length);
+        }
+
+        /// <summary>
+        /// Gets the latest available data from the microphone.
+        /// </summary>
+        /// <param name="buffer">Buffer, in bytes, of the captured data (16-bit PCM).</param>
+        /// <param name="offset">Byte offset.</param>
+        /// <param name="count">Amount, in bytes.</param>
+        /// <returns>The buffer size, in bytes, of the captured data.</returns>
+        public int GetData(byte[] buffer, int offset, int count)
+        {
+            return PlatformGetData(buffer, offset, count);
+        }
+
+        #endregion
+
+        #region Public Events
+
+        /// <summary>
+        /// Event fired when the audio data are available.
+        /// </summary>
+        public event EventHandler<EventArgs> BufferReady;
+
+        #endregion
+
+        #region Static Methods
+
+        internal static void UpdateMicrophones()
+        {
+            // querying all running microphones for new samples available
+            if (_allMicrophones != null)
+                for (int i = 0; i < _allMicrophones.Count; i++)
+                    _allMicrophones[i].Update();
+        }
+
+        internal static void StopMicrophones()
+        {
+            // stopping all running microphones before shutting down audio devices
+            if (_allMicrophones != null)
+                for (int i = 0; i < _allMicrophones.Count; i++)
+                    _allMicrophones[i].Stop();
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Audio/NoAudioHardwareException.cs b/MonoGame.Framework/Audio/NoAudioHardwareException.cs
new file mode 100644
index 00000000000..665122dbaef
--- /dev/null
+++ b/MonoGame.Framework/Audio/NoAudioHardwareException.cs
@@ -0,0 +1,36 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+
+    /// <summary>
+    /// The exception thrown when no audio hardware is present, or driver issues are detected.
+    /// </summary>
+    [DataContract]
+#if WINDOWS_UAP
+    public sealed class NoAudioHardwareException : Exception
+#else
+    public sealed class NoAudioHardwareException : ExternalException
+#endif
+    {
+        /// <param name="msg">A message describing the error.</param>
+        public NoAudioHardwareException(string msg)
+            : base(msg)
+        {
+        }
+
+        /// <param name="msg">A message describing the error.</param>
+        /// <param name="innerException">The exception that is the underlying cause of the current exception. If not null, the current exception is raised in a try/catch block that handled the innerException.</param>
+        public NoAudioHardwareException(string msg, Exception innerException)
+            : base(msg, innerException)
+        {
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/NoMicrophoneConnectedException.cs b/MonoGame.Framework/Audio/NoMicrophoneConnectedException.cs
new file mode 100644
index 00000000000..5dac7079e83
--- /dev/null
+++ b/MonoGame.Framework/Audio/NoMicrophoneConnectedException.cs
@@ -0,0 +1,31 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+
+    /// <summary>
+    /// The exception thrown when no audio hardware is present, or driver issues are detected.
+    /// </summary>
+    [DataContract]
+    public sealed class NoMicrophoneConnectedException : Exception
+    {
+        /// <param name="msg">A message describing the error.</param>
+        public NoMicrophoneConnectedException(string msg)
+            : base(msg)
+        {
+        }
+
+        /// <param name="msg">A message describing the error.</param>
+        /// <param name="innerException">The exception that is the underlying cause of the current exception. If not null, the current exception is raised in a try/catch block that handled the innerException.</param>
+        public NoMicrophoneConnectedException(string msg, Exception innerException)
+            : base(msg, innerException)
+        {
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/OALSoundBuffer.cs b/MonoGame.Framework/Audio/OALSoundBuffer.cs
new file mode 100644
index 00000000000..dd7b8992bac
--- /dev/null
+++ b/MonoGame.Framework/Audio/OALSoundBuffer.cs
@@ -0,0 +1,99 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using MonoGame.OpenAL;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+	internal class OALSoundBuffer : IDisposable
+	{
+		int openALDataBuffer;
+		ALFormat openALFormat;
+		int dataSize;
+        bool _isDisposed;
+
+		public OALSoundBuffer()
+		{
+            AL.GenBuffers(1, out openALDataBuffer);
+            ALHelper.CheckError("Failed to generate OpenAL data buffer.");
+		}
+
+        ~OALSoundBuffer()
+        {
+            Dispose(false);
+        }
+
+		public int OpenALDataBuffer
+        {
+			get
+            {
+				return openALDataBuffer;
+			}
+		}
+
+		public double Duration
+        {
+			get;
+			set;
+		}
+
+        public void BindDataBuffer(byte[] dataBuffer, ALFormat format, int size, int sampleRate, int sampleAlignment = 0)
+        {
+            if ((format == ALFormat.MonoMSAdpcm || format == ALFormat.StereoMSAdpcm) && !OpenALSoundController.Instance.SupportsAdpcm)
+                throw new InvalidOperationException("MS-ADPCM is not supported by this OpenAL driver");
+            if ((format == ALFormat.MonoIma4 || format == ALFormat.StereoIma4) && !OpenALSoundController.Instance.SupportsIma4)
+                throw new InvalidOperationException("IMA/ADPCM is not supported by this OpenAL driver");
+
+            openALFormat = format;
+            dataSize = size;
+            int unpackedSize = 0;
+
+            if (sampleAlignment > 0)
+            {
+                AL.Bufferi(openALDataBuffer, ALBufferi.UnpackBlockAlignmentSoft, sampleAlignment);
+                ALHelper.CheckError("Failed to fill buffer.");
+            }
+
+            AL.BufferData(openALDataBuffer, openALFormat, dataBuffer, size, sampleRate);
+            ALHelper.CheckError("Failed to fill buffer.");
+
+            int bits, channels;
+            Duration = -1;
+            AL.GetBuffer(openALDataBuffer, ALGetBufferi.Bits, out bits);
+            ALHelper.CheckError("Failed to get buffer bits");
+            AL.GetBuffer(openALDataBuffer, ALGetBufferi.Channels, out channels);
+            ALHelper.CheckError("Failed to get buffer channels");
+            AL.GetBuffer(openALDataBuffer, ALGetBufferi.Size, out unpackedSize);
+            ALHelper.CheckError("Failed to get buffer size");
+            Duration = (float)(unpackedSize / ((bits / 8) * channels)) / (float)sampleRate;
+        }
+
+		public void Dispose()
+		{
+            Dispose(true);
+            GC.SuppressFinalize(this);
+		}
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_isDisposed)
+            {
+                if (disposing)
+                {
+                    // Clean up managed objects
+                }
+                // Release unmanaged resources
+                if (AL.IsBuffer(openALDataBuffer))
+                {
+                    ALHelper.CheckError("Failed to fetch buffer state.");
+                    AL.DeleteBuffers(1, ref openALDataBuffer);
+                    ALHelper.CheckError("Failed to delete buffer.");
+                }
+
+                _isDisposed = true;
+            }
+        }
+	}
+}
diff --git a/MonoGame.Framework/Audio/OggStream.cs b/MonoGame.Framework/Audio/OggStream.cs
new file mode 100644
index 00000000000..5f6064ce4be
--- /dev/null
+++ b/MonoGame.Framework/Audio/OggStream.cs
@@ -0,0 +1,529 @@
+// This code originated from:
+//
+//    http://theinstructionlimit.com/ogg-streaming-using-opentk-and-nvorbis
+//    https://github.com/renaudbedard/nvorbis/
+//
+// It was released to the public domain by the author (Renaud Bedard).
+// No other license is intended or required.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using NVorbis;
+using MonoGame.OpenAL;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    internal class OggStream : IDisposable
+    {
+        const int DefaultBufferCount = 3;
+
+        internal readonly object stopMutex = new object();
+        internal readonly object prepareMutex = new object();
+
+        internal readonly int alSourceId;
+        internal readonly int[] alBufferIds;
+
+        readonly int alFilterId;
+        readonly string oggFileName;
+
+        internal VorbisReader Reader { get; private set; }
+        internal bool Ready { get; private set; }
+        internal bool Preparing { get; private set; }
+
+        public Action FinishedAction { get; private set; }
+        public int BufferCount { get; private set; }
+
+        public OggStream(string filename, Action finishedAction = null, int bufferCount = DefaultBufferCount)
+        {
+            oggFileName = filename;
+            FinishedAction = finishedAction;
+            BufferCount = bufferCount;
+
+            alBufferIds = AL.GenBuffers(bufferCount);
+            ALHelper.CheckError("Failed to generate buffers.");
+            alSourceId = OpenALSoundController.Instance.ReserveSource();
+
+            if (OggStreamer.Instance.XRam.IsInitialized)
+            {
+                OggStreamer.Instance.XRam.SetBufferMode(BufferCount, ref alBufferIds[0], XRamExtension.XRamStorage.Hardware);
+                ALHelper.CheckError("Failed to activate Xram.");
+            }
+
+            Volume = 1;
+
+            if (OggStreamer.Instance.Efx.IsInitialized)
+            {
+                alFilterId = OggStreamer.Instance.Efx.GenFilter();
+                ALHelper.CheckError("Failed to generate Efx filter.");
+                OggStreamer.Instance.Efx.Filter(alFilterId, EfxFilteri.FilterType, (int)EfxFilterType.Lowpass);
+                ALHelper.CheckError("Failed to set Efx filter type.");
+                OggStreamer.Instance.Efx.Filter(alFilterId, EfxFilterf.LowpassGain, 1);
+                ALHelper.CheckError("Failed to set Efx filter value.");
+                LowPassHFGain = 1;
+            }
+        }
+
+        public void Prepare()
+        {
+            if (Preparing) return;
+
+            var state = AL.GetSourceState(alSourceId);
+            ALHelper.CheckError("Failed to get source state.");
+
+            lock (stopMutex)
+            {
+                switch (state)
+                {
+                    case ALSourceState.Playing:
+                    case ALSourceState.Paused:
+                        return;
+
+                    case ALSourceState.Stopped:
+                        lock (prepareMutex)
+                        {
+                            Close();
+                            Empty();
+                        }
+                        break;
+                }
+
+                if (!Ready)
+                {
+                    lock (prepareMutex)
+                    {
+                        Preparing = true;
+                        Open(precache: true);
+                    }
+                }
+            }
+        }
+
+        public void Play()
+        {
+            var state = AL.GetSourceState(alSourceId);
+            ALHelper.CheckError("Failed to get source state.");
+
+            switch (state)
+            {
+                case ALSourceState.Playing: return;
+                case ALSourceState.Paused:
+                    Resume();
+                    return;
+            }
+
+            Prepare();
+
+            AL.SourcePlay(alSourceId);
+            ALHelper.CheckError("Failed to play source.");
+
+            Preparing = false;
+
+            OggStreamer.Instance.AddStream(this);
+        }
+
+        public void Pause()
+        {
+            var state = AL.GetSourceState(alSourceId);
+            ALHelper.CheckError("Failed to get source state.");
+            if (state != ALSourceState.Playing)
+                return;
+
+            OggStreamer.Instance.RemoveStream(this);
+            AL.SourcePause(alSourceId);
+            ALHelper.CheckError("Failed to pause source.");
+        }
+
+        public void Resume()
+        {
+            var state = AL.GetSourceState(alSourceId);
+            ALHelper.CheckError("Failed to get source state.");
+            if (state != ALSourceState.Paused)
+                return;
+
+            OggStreamer.Instance.AddStream(this);
+            AL.SourcePlay(alSourceId);
+            ALHelper.CheckError("Failed to play source.");
+        }
+
+        public void Stop()
+        {
+            var state = AL.GetSourceState(alSourceId);
+            ALHelper.CheckError("Failed to get source state.");
+            if (state == ALSourceState.Playing || state == ALSourceState.Paused)
+                StopPlayback();
+
+            lock (stopMutex)
+            {
+                OggStreamer.Instance.RemoveStream(this);
+
+                lock (prepareMutex)
+                {
+                    if (state != ALSourceState.Initial)
+                        Empty(); // force the queued buffers to be unqueued to avoid issues on Mac
+                }
+            }
+            AL.Source(alSourceId, ALSourcei.Buffer, 0);
+            ALHelper.CheckError("Failed to free source from buffers.");
+        }
+
+        public void SeekToPosition(TimeSpan pos)
+        {
+            Reader.DecodedTime = pos;
+            AL.SourceStop(alSourceId);
+            ALHelper.CheckError("Failed to stop source.");
+        }
+
+        public TimeSpan GetPosition()
+        {
+            if (Reader == null)
+                return TimeSpan.Zero;
+
+            return Reader.DecodedTime;
+        }
+
+        public TimeSpan GetLength()
+        {
+            return Reader.TotalTime;
+        }
+
+        float lowPassHfGain;
+        public float LowPassHFGain
+        {
+            get { return lowPassHfGain; }
+            set
+            {
+                if (OggStreamer.Instance.Efx.IsInitialized)
+                {
+                    OggStreamer.Instance.Efx.Filter(alFilterId, EfxFilterf.LowpassGainHF, lowPassHfGain = value);
+                    ALHelper.CheckError("Failed to set Efx filter.");
+                    OggStreamer.Instance.Efx.BindFilterToSource(alSourceId, alFilterId);
+                    ALHelper.CheckError("Failed to bind Efx filter to source.");
+                }
+            }
+        }
+
+        float volume;
+        public float Volume
+        {
+            get { return volume; }
+            set
+            {
+                AL.Source(alSourceId, ALSourcef.Gain, volume = value);
+                ALHelper.CheckError("Failed to set volume.");
+            }
+        }
+
+        public bool IsLooped { get; set; }
+
+        public void Dispose()
+        {
+            var state = AL.GetSourceState(alSourceId);
+            ALHelper.CheckError("Failed to get the source state.");
+            if (state == ALSourceState.Playing || state == ALSourceState.Paused)
+                StopPlayback();
+
+            lock (prepareMutex)
+            {
+                OggStreamer.Instance.RemoveStream(this);
+
+                if (state != ALSourceState.Initial)
+                    Empty();
+
+                Close();
+            }
+
+            AL.Source(alSourceId, ALSourcei.Buffer, 0);
+            ALHelper.CheckError("Failed to free source from buffers.");
+            OpenALSoundController.Instance.RecycleSource(alSourceId);
+            AL.DeleteBuffers(alBufferIds);
+            ALHelper.CheckError("Failed to delete buffer.");
+            if (OggStreamer.Instance.Efx.IsInitialized)
+            {
+                OggStreamer.Instance.Efx.DeleteFilter(alFilterId);
+                ALHelper.CheckError("Failed to delete EFX filter.");
+            }
+
+
+        }
+
+        void StopPlayback()
+        {
+            AL.SourceStop(alSourceId);
+            ALHelper.CheckError("Failed to stop source.");
+        }
+
+        void Empty()
+        {
+            int queued;
+            AL.GetSource(alSourceId, ALGetSourcei.BuffersQueued, out queued);
+            ALHelper.CheckError("Failed to fetch queued buffers.");
+            if (queued > 0)
+            {
+                try
+                {
+                    AL.SourceUnqueueBuffers(alSourceId, queued);
+                    ALHelper.CheckError("Failed to unqueue buffers (first attempt).");
+                }
+                catch (InvalidOperationException)
+                {
+                    // This is a bug in the OpenAL implementation
+                    // Salvage what we can
+                    int processed;
+                    AL.GetSource(alSourceId, ALGetSourcei.BuffersProcessed, out processed);
+                    ALHelper.CheckError("Failed to fetch processed buffers.");
+                    var salvaged = new int[processed];
+                    if (processed > 0)
+                    {
+                        AL.SourceUnqueueBuffers(alSourceId, processed, out salvaged);
+                        ALHelper.CheckError("Failed to unqueue buffers (second attempt).");
+                    }
+
+                    // Try turning it off again?
+                    AL.SourceStop(alSourceId);
+                    ALHelper.CheckError("Failed to stop source.");
+
+                    Empty();
+                }
+            }
+        }
+
+        internal void Open(bool precache = false)
+        {
+            Reader = new VorbisReader(oggFileName);
+
+            if (precache)
+            {
+                // Fill first buffer synchronously
+                OggStreamer.Instance.FillBuffer(this, alBufferIds[0]);
+                AL.SourceQueueBuffer(alSourceId, alBufferIds[0]);
+                ALHelper.CheckError("Failed to queue buffer.");
+            }
+
+            Ready = true;
+        }
+
+        internal void Close()
+        {
+            if (Reader != null)
+            {
+                Reader.Dispose();
+                Reader = null;
+            }
+            Ready = false;
+        }
+    }
+
+    internal class OggStreamer : IDisposable
+    {
+        public readonly XRamExtension XRam = new XRamExtension();
+        public readonly EffectsExtension Efx = OpenALSoundController.Efx;
+
+        const float DefaultUpdateRate = 10;
+        const int DefaultBufferSize = 44100;
+
+        static readonly object singletonMutex = new object();
+
+        readonly object iterationMutex = new object();
+        readonly object readMutex = new object();
+
+        readonly float[] readSampleBuffer;
+        readonly short[] castBuffer;
+
+        readonly HashSet<OggStream> streams = new HashSet<OggStream>();
+        readonly List<OggStream> threadLocalStreams = new List<OggStream>();
+
+        readonly Thread underlyingThread;
+        volatile bool cancelled;
+
+        bool pendingFinish;
+
+        public float UpdateRate { get; private set; }
+        public int BufferSize { get; private set; }
+
+        static OggStreamer instance;
+        public static OggStreamer Instance
+        {
+            get
+            {
+                lock (singletonMutex)
+                {
+                    if (instance == null)
+                        throw new InvalidOperationException("No instance running");
+                    return instance;
+                }
+            }
+            private set { lock (singletonMutex) instance = value; }
+        }
+
+        public OggStreamer(int bufferSize = DefaultBufferSize, float updateRate = DefaultUpdateRate)
+        {
+            UpdateRate = updateRate;
+            BufferSize = bufferSize;
+            pendingFinish = false;
+
+            lock (singletonMutex)
+            {
+                if (instance != null)
+                    throw new InvalidOperationException("Already running");
+
+                Instance = this;
+                underlyingThread = new Thread(EnsureBuffersFilled) { Priority = ThreadPriority.Lowest };
+                underlyingThread.Start();
+            }
+
+            readSampleBuffer = new float[bufferSize];
+            castBuffer = new short[bufferSize];
+        }
+
+        public void Dispose()
+        {
+            lock (singletonMutex)
+            {
+                Debug.Assert(Instance == this, "Two instances running, somehow...?");
+
+                cancelled = true;
+                lock (iterationMutex)
+                    streams.Clear();
+
+                Instance = null;
+            }
+        }
+
+        internal bool AddStream(OggStream stream)
+        {
+            lock (iterationMutex)
+                return streams.Add(stream);
+        }
+
+        internal bool RemoveStream(OggStream stream)
+        {
+            lock (iterationMutex)
+                return streams.Remove(stream);
+        }
+
+        public bool FillBuffer(OggStream stream, int bufferId)
+        {
+            int readSamples;
+            lock (readMutex)
+            {
+                readSamples = stream.Reader.ReadSamples(readSampleBuffer, 0, BufferSize);
+                CastBuffer(readSampleBuffer, castBuffer, readSamples);
+            }
+            AL.BufferData(bufferId, stream.Reader.Channels == 1 ? ALFormat.Mono16 : ALFormat.Stereo16, castBuffer,
+                readSamples * sizeof(short), stream.Reader.SampleRate);
+            ALHelper.CheckError("Failed to fill buffer, readSamples = {0}, SampleRate = {1}, buffer.Length = {2}.", readSamples, stream.Reader.SampleRate, castBuffer.Length);
+
+
+            return readSamples != BufferSize;
+        }
+        static void CastBuffer(float[] inBuffer, short[] outBuffer, int length)
+        {
+            for (int i = 0; i < length; i++)
+            {
+                var temp = (int)(32767f * inBuffer[i]);
+                if (temp > short.MaxValue) temp = short.MaxValue;
+                else if (temp < short.MinValue) temp = short.MinValue;
+                outBuffer[i] = (short)temp;
+            }
+        }
+
+        void EnsureBuffersFilled()
+        {
+            while (!cancelled)
+            {
+                Thread.Sleep((int) (1000 / ((UpdateRate <= 0) ? 1 : UpdateRate)));
+                if (cancelled) break;
+
+                threadLocalStreams.Clear();
+                lock (iterationMutex) threadLocalStreams.AddRange(streams);
+
+                foreach (var stream in threadLocalStreams)
+                {
+                    lock (stream.prepareMutex)
+                    {
+                        lock (iterationMutex)
+                            if (!streams.Contains(stream))
+                                continue;
+
+                        bool finished = false;
+
+                        int queued;
+                        AL.GetSource(stream.alSourceId, ALGetSourcei.BuffersQueued, out queued);
+                        ALHelper.CheckError("Failed to fetch queued buffers.");
+                        int processed;
+                        AL.GetSource(stream.alSourceId, ALGetSourcei.BuffersProcessed, out processed);
+                        ALHelper.CheckError("Failed to fetch processed buffers.");
+
+                        if (processed == 0 && queued == stream.BufferCount) continue;
+
+                        int[] tempBuffers;
+                        if (processed > 0)
+                        {
+                            tempBuffers = AL.SourceUnqueueBuffers(stream.alSourceId, processed);
+                            ALHelper.CheckError("Failed to unqueue buffers.");
+                        }
+                        else
+                            tempBuffers = stream.alBufferIds.Skip(queued).ToArray();
+
+                        int bufferFilled = 0;
+                        for (int i = 0; i < tempBuffers.Length && !pendingFinish; i++)
+                        {
+                            finished |= FillBuffer(stream, tempBuffers[i]);
+                            bufferFilled++;
+
+                            if (finished)
+                            {
+                                if (stream.IsLooped)
+                                {
+                                    stream.Close();
+                                    stream.Open();
+                                }
+                                else
+                                {
+                                    pendingFinish = true;
+                                }
+                            }
+                        }
+
+                        if (pendingFinish && queued == 0)
+                        {
+                            pendingFinish = false;
+                            lock (iterationMutex)
+                                streams.Remove(stream);
+                            if (stream.FinishedAction != null)
+                                stream.FinishedAction.Invoke();
+                        }
+                        else if (!finished && bufferFilled > 0) // queue only successfully filled buffers
+                        {
+                            AL.SourceQueueBuffers(stream.alSourceId, bufferFilled, tempBuffers);
+                            ALHelper.CheckError("Failed to queue buffers.");
+                        }
+                        else if (!stream.IsLooped)
+                            continue;
+                    }
+
+                    lock (stream.stopMutex)
+                    {
+                        if (stream.Preparing) continue;
+
+                        lock (iterationMutex)
+                            if (!streams.Contains(stream))
+                                continue;
+
+                        var state = AL.GetSourceState(stream.alSourceId);
+                        ALHelper.CheckError("Failed to get source state.");
+                        if (state == ALSourceState.Stopped)
+                        {
+                            AL.SourcePlay(stream.alSourceId);
+                            ALHelper.CheckError("Failed to play.");
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Audio/OpenAL.cs b/MonoGame.Framework/Audio/OpenAL.cs
new file mode 100644
index 00000000000..9a8eb4202ed
--- /dev/null
+++ b/MonoGame.Framework/Audio/OpenAL.cs
@@ -0,0 +1,887 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.InteropServices;
+using Microsoft.Xna.Framework.Audio;
+using MonoGame.Utilities;
+using System.IO;
+
+namespace MonoGame.OpenAL
+{
+    internal enum ALFormat
+    {
+        Mono8 = 0x1100,
+        Mono16 = 0x1101,
+        Stereo8 = 0x1102,
+        Stereo16 = 0x1103,
+        MonoIma4 = 0x1300,
+        StereoIma4 = 0x1301,
+        MonoMSAdpcm = 0x1302,
+        StereoMSAdpcm = 0x1303,
+        MonoFloat32 = 0x10010,
+        StereoFloat32 = 0x10011,
+    }
+
+    internal enum ALError
+    {
+        NoError = 0,
+        InvalidName = 0xA001,
+        InvalidEnum = 0xA002,
+        InvalidValue = 0xA003,
+        InvalidOperation = 0xA004,
+        OutOfMemory = 0xA005,
+    }
+
+    internal enum ALGetString
+    {
+        Extensions = 0xB004,
+    }
+
+    internal enum ALBufferi
+    {
+        UnpackBlockAlignmentSoft = 0x200C,
+        LoopSoftPointsExt = 0x2015,
+    }
+
+    internal enum ALGetBufferi
+    {
+        Bits = 0x2002,
+        Channels = 0x2003,
+        Size = 0x2004,
+    }
+
+    internal enum ALSourceb
+    {
+        Looping = 0x1007,
+    }
+
+    internal enum ALSourcei
+    {
+        SourceRelative = 0x202,
+        Buffer = 0x1009,
+        EfxDirectFilter = 0x20005,
+        EfxAuxilarySendFilter = 0x20006,
+    }
+
+    internal enum ALSourcef
+    {
+        Pitch = 0x1003,
+        Gain = 0x100A,
+        ReferenceDistance = 0x1020
+    }
+
+    internal enum ALGetSourcei
+    {
+        SampleOffset = 0x1025,
+        SourceState = 0x1010,
+        BuffersQueued = 0x1015,
+        BuffersProcessed = 0x1016,
+    }
+
+    internal enum ALSourceState
+    {
+        Initial = 0x1011,
+        Playing = 0x1012,
+        Paused = 0x1013,
+        Stopped = 0x1014,
+    }
+
+    internal enum ALListener3f
+    {
+        Position = 0x1004,
+    }
+
+    internal enum ALSource3f
+    {
+        Position = 0x1004,
+        Velocity = 0x1006,
+    }
+
+    internal enum ALDistanceModel
+    {
+        None = 0,
+        InverseDistanceClamped = 0xD002,
+    }
+
+    internal enum AlcError
+    {
+        NoError = 0,
+    }
+
+    internal enum AlcGetString
+    {
+        CaptureDeviceSpecifier = 0x0310,
+        CaptureDefaultDeviceSpecifier = 0x0311,
+        Extensions = 0x1006,
+    }
+
+    internal enum AlcGetInteger
+    {
+        CaptureSamples = 0x0312,
+    }
+
+    internal enum EfxFilteri
+    {
+        FilterType = 0x8001,
+    }
+
+    internal enum EfxFilterf
+    {
+        LowpassGain = 0x0001,
+        LowpassGainHF = 0x0002,
+        HighpassGain = 0x0001,
+        HighpassGainLF = 0x0002,
+        BandpassGain = 0x0001,
+        BandpassGainLF = 0x0002,
+        BandpassGainHF = 0x0003,
+    }
+
+    internal enum EfxFilterType
+    {
+        None = 0x0000,
+        Lowpass = 0x0001,
+        Highpass = 0x0002,
+        Bandpass = 0x0003,
+    }
+
+    internal enum EfxEffecti
+    {
+        EffectType = 0x8001,
+        SlotEffect = 0x0001,
+    }
+
+    internal enum EfxEffectSlotf
+    {
+        EffectSlotGain = 0x0002,
+    }
+
+    internal enum EfxEffectf
+    {
+        EaxReverbDensity = 0x0001,
+        EaxReverbDiffusion = 0x0002,
+        EaxReverbGain = 0x0003,
+        EaxReverbGainHF = 0x0004,
+        EaxReverbGainLF = 0x0005,
+        DecayTime = 0x0006,
+        DecayHighFrequencyRatio = 0x0007,
+        DecayLowFrequencyRation = 0x0008,
+        EaxReverbReflectionsGain = 0x0009,
+        EaxReverbReflectionsDelay = 0x000A,
+        ReflectionsPain = 0x000B,
+        LateReverbGain = 0x000C,
+        LateReverbDelay = 0x000D,
+        LateRevertPain = 0x000E,
+        EchoTime = 0x000F,
+        EchoDepth = 0x0010,
+        ModulationTime = 0x0011,
+        ModulationDepth = 0x0012,
+        AirAbsorbsionHighFrequency = 0x0013,
+        EaxReverbHFReference = 0x0014,
+        EaxReverbLFReference = 0x0015,
+        RoomRolloffFactor = 0x0016,
+        DecayHighFrequencyLimit = 0x0017,
+    }
+
+    internal enum EfxEffectType
+    {
+        Reverb = 0x8000,
+    }
+
+    internal class AL
+    {
+        public static IntPtr NativeLibrary = GetNativeLibrary();
+
+        private static IntPtr GetNativeLibrary()
+        {
+            var ret = IntPtr.Zero;
+
+#if DESKTOPGL
+            // Load bundled library
+            var assemblyLocation = Path.GetDirectoryName(typeof(AL).Assembly.Location);
+            if (CurrentPlatform.OS == OS.Windows && Environment.Is64BitProcess)
+                ret = FuncLoader.LoadLibrary(Path.Combine(assemblyLocation, "x64/soft_oal.dll"));
+            else if (CurrentPlatform.OS == OS.Windows && !Environment.Is64BitProcess)
+                ret = FuncLoader.LoadLibrary(Path.Combine(assemblyLocation, "x86/soft_oal.dll"));
+            else if (CurrentPlatform.OS == OS.Linux && Environment.Is64BitProcess)
+                ret = FuncLoader.LoadLibrary(Path.Combine(assemblyLocation, "x64/libopenal.so.1"));
+            else if (CurrentPlatform.OS == OS.Linux && !Environment.Is64BitProcess)
+                ret = FuncLoader.LoadLibrary(Path.Combine(assemblyLocation, "x86/libopenal.so.1"));
+            else if (CurrentPlatform.OS == OS.MacOSX)
+                ret = FuncLoader.LoadLibrary(Path.Combine(assemblyLocation, "libopenal.1.dylib"));
+
+            // Load system library
+            if (ret == IntPtr.Zero)
+            {
+                if (CurrentPlatform.OS == OS.Windows)
+                    ret = FuncLoader.LoadLibrary("soft_oal.dll");
+                else if (CurrentPlatform.OS == OS.Linux)
+                    ret = FuncLoader.LoadLibrary("libopenal.so.1");
+                else
+                    ret = FuncLoader.LoadLibrary("libopenal.1.dylib");
+            }
+#elif ANDROID
+            ret = FuncLoader.LoadLibrary("libopenal32.so");
+
+            if (ret == IntPtr.Zero)
+            {
+                var appFilesDir = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
+                var appDir = Path.GetDirectoryName(appFilesDir);
+                var lib = Path.Combine(appDir, "lib", "libopenal32.so");
+
+                ret = FuncLoader.LoadLibrary(lib);
+            }
+#else
+            ret = FuncLoader.LoadLibrary("/System/Library/Frameworks/OpenAL.framework/OpenAL");
+#endif
+
+            return ret;
+        }
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alenable(int cap);
+        internal static d_alenable Enable = FuncLoader.LoadFunction<d_alenable>(NativeLibrary, "alEnable");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_albufferdata(uint bid, int format, IntPtr data, int size, int freq);
+        internal static d_albufferdata alBufferData = FuncLoader.LoadFunction<d_albufferdata>(NativeLibrary, "alBufferData");
+
+        internal static void BufferData(int bid, ALFormat format, byte[] data, int size, int freq)
+        {
+            var handle = GCHandle.Alloc(data, GCHandleType.Pinned);
+            alBufferData((uint)bid, (int)format, handle.AddrOfPinnedObject(), size, freq);
+            handle.Free();
+        }
+
+        internal static void BufferData(int bid, ALFormat format, short[] data, int size, int freq)
+        {
+            var handle = GCHandle.Alloc(data, GCHandleType.Pinned);
+            alBufferData((uint)bid, (int)format, handle.AddrOfPinnedObject(), size, freq);
+            handle.Free();
+        }
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal unsafe delegate void d_aldeletebuffers(int n, int* buffers);
+        internal static d_aldeletebuffers alDeleteBuffers = FuncLoader.LoadFunction<d_aldeletebuffers>(NativeLibrary, "alDeleteBuffers");
+
+        internal static void DeleteBuffers(int[] buffers)
+        {
+            DeleteBuffers(buffers.Length, ref buffers[0]);
+        }
+
+        internal unsafe static void DeleteBuffers(int n, ref int buffers)
+        {
+            fixed (int* pbuffers = &buffers)
+            {
+                alDeleteBuffers(n, pbuffers);
+            }
+        }
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_albufferi(int buffer, ALBufferi param, int value);
+        internal static d_albufferi Bufferi = FuncLoader.LoadFunction<d_albufferi>(NativeLibrary, "alBufferi");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_algetbufferi(int bid, ALGetBufferi param, out int value);
+        internal static d_algetbufferi GetBufferi = FuncLoader.LoadFunction<d_algetbufferi>(NativeLibrary, "alGetBufferi");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_albufferiv(int bid, ALBufferi param, int[] values);
+        internal static d_albufferiv Bufferiv = FuncLoader.LoadFunction<d_albufferiv>(NativeLibrary, "alBufferiv");
+
+        internal static void GetBuffer(int bid, ALGetBufferi param, out int value)
+        {
+            GetBufferi(bid, param, out value);
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal unsafe delegate void d_algenbuffers(int count, int* buffers);
+        internal static d_algenbuffers alGenBuffers = FuncLoader.LoadFunction<d_algenbuffers>(NativeLibrary, "alGenBuffers");
+
+        internal unsafe static void GenBuffers(int count, out int[] buffers)
+        {
+            buffers = new int[count];
+            fixed (int* ptr = &buffers[0])
+            {
+                alGenBuffers(count, ptr);
+            }
+        }
+
+        internal static void GenBuffers(int count, out int buffer)
+        {
+            int[] ret;
+            GenBuffers(count, out ret);
+            buffer = ret[0];
+        }
+
+        internal static int[] GenBuffers(int count)
+        {
+            int[] ret;
+            GenBuffers(count, out ret);
+            return ret;
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_algensources(int n, uint[] sources);
+        internal static d_algensources alGenSources = FuncLoader.LoadFunction<d_algensources>(NativeLibrary, "alGenSources");
+
+
+        internal static void GenSources(int[] sources)
+        {
+            uint[] temp = new uint[sources.Length];
+            alGenSources(temp.Length, temp);
+            for (int i = 0; i < temp.Length; i++)
+            {
+                sources[i] = (int)temp[i];
+            }
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate ALError d_algeterror();
+        internal static d_algeterror GetError = FuncLoader.LoadFunction<d_algeterror>(NativeLibrary, "alGetError");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate bool d_alisbuffer(uint buffer);
+        internal static d_alisbuffer alIsBuffer = FuncLoader.LoadFunction<d_alisbuffer>(NativeLibrary, "alIsBuffer");
+
+        internal static bool IsBuffer(int buffer)
+        {
+            return alIsBuffer((uint)buffer);
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alsourcepause(uint source);
+        internal static d_alsourcepause alSourcePause = FuncLoader.LoadFunction<d_alsourcepause>(NativeLibrary, "alSourcePause");
+
+        internal static void SourcePause(int source)
+        {
+            alSourcePause((uint)source);
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alsourceplay(uint source);
+        internal static d_alsourceplay alSourcePlay = FuncLoader.LoadFunction<d_alsourceplay>(NativeLibrary, "alSourcePlay");
+
+        internal static void SourcePlay(int source)
+        {
+            alSourcePlay((uint)source);
+        }
+
+        internal static string GetErrorString(ALError errorCode)
+        {
+            return errorCode.ToString();
+        }
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate bool d_alissource(int source);
+        internal static d_alissource IsSource = FuncLoader.LoadFunction<d_alissource>(NativeLibrary, "alIsSource");
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_aldeletesources(int n, ref int sources);
+        internal static d_aldeletesources alDeleteSources = FuncLoader.LoadFunction<d_aldeletesources>(NativeLibrary, "alDeleteSources");
+
+        internal static void DeleteSource(int source)
+        {
+            alDeleteSources(1, ref source);
+        }
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alsourcestop(int sourceId);
+        internal static d_alsourcestop SourceStop = FuncLoader.LoadFunction<d_alsourcestop>(NativeLibrary, "alSourceStop");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alsourcei(int sourceId, int i, int a);
+        internal static d_alsourcei alSourcei = FuncLoader.LoadFunction<d_alsourcei>(NativeLibrary, "alSourcei");
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alsource3i(int sourceId, ALSourcei i, int a, int b, int c);
+        internal static d_alsource3i alSource3i = FuncLoader.LoadFunction<d_alsource3i>(NativeLibrary, "alSource3i");
+
+        internal static void Source(int sourceId, ALSourcei i, int a)
+        {
+            alSourcei(sourceId, (int)i, a);
+        }
+
+        internal static void Source(int sourceId, ALSourceb i, bool a)
+        {
+            alSourcei(sourceId, (int)i, a ? 1 : 0);
+        }
+
+        internal static void Source(int sourceId, ALSource3f i, float x, float y, float z)
+        {
+            alSource3f(sourceId, i, x, y, z);
+        }
+
+        internal static void Source(int sourceId, ALSourcef i, float dist)
+        {
+            alSourcef(sourceId, i, dist);
+        }
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alsourcef(int sourceId, ALSourcef i, float a);
+        internal static d_alsourcef alSourcef = FuncLoader.LoadFunction<d_alsourcef>(NativeLibrary, "alSourcef");
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alsource3f(int sourceId, ALSource3f i, float x, float y, float z);
+        internal static d_alsource3f alSource3f = FuncLoader.LoadFunction<d_alsource3f>(NativeLibrary, "alSource3f");
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_algetsourcei(int sourceId, ALGetSourcei i, out int state);
+        internal static d_algetsourcei GetSource = FuncLoader.LoadFunction<d_algetsourcei>(NativeLibrary, "alGetSourcei");
+
+        internal static ALSourceState GetSourceState(int sourceId)
+        {
+            int state;
+            GetSource(sourceId, ALGetSourcei.SourceState, out state);
+            return (ALSourceState)state;
+        }
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_algetlistener3f(ALListener3f param, out float value1, out float value2, out float value3);
+        internal static d_algetlistener3f GetListener = FuncLoader.LoadFunction<d_algetlistener3f>(NativeLibrary, "alGetListener3f");
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_aldistancemodel(ALDistanceModel model);
+        internal static d_aldistancemodel DistanceModel = FuncLoader.LoadFunction<d_aldistancemodel>(NativeLibrary, "alDistanceModel");
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_aldopplerfactor(float value);
+        internal static d_aldopplerfactor DopplerFactor = FuncLoader.LoadFunction<d_aldopplerfactor>(NativeLibrary, "alDopplerFactor");
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal unsafe delegate void d_alsourcequeuebuffers(int sourceId, int numEntries, int* buffers);
+        internal static d_alsourcequeuebuffers alSourceQueueBuffers = FuncLoader.LoadFunction<d_alsourcequeuebuffers>(NativeLibrary, "alSourceQueueBuffers");
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal unsafe delegate void d_alsourceunqueuebuffers(int sourceId, int numEntries, int* salvaged);
+        internal static d_alsourceunqueuebuffers alSourceUnqueueBuffers = FuncLoader.LoadFunction<d_alsourceunqueuebuffers>(NativeLibrary, "alSourceUnqueueBuffers");
+
+        [CLSCompliant(false)]
+        internal static unsafe void SourceQueueBuffers(int sourceId, int numEntries, int[] buffers)
+        {
+            fixed (int* ptr = &buffers[0])
+            {
+                AL.alSourceQueueBuffers(sourceId, numEntries, ptr);
+            }
+        }
+
+        internal unsafe static void SourceQueueBuffer(int sourceId, int buffer)
+        {
+            AL.alSourceQueueBuffers(sourceId, 1, &buffer);
+        }
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alsourceunqueuebuffers2(int sid, int numEntries, out int[] bids);
+        internal static d_alsourceunqueuebuffers2 alSourceUnqueueBuffers2 = FuncLoader.LoadFunction<d_alsourceunqueuebuffers2>(NativeLibrary, "alSourceUnqueueBuffers");
+
+        internal static unsafe int[] SourceUnqueueBuffers(int sourceId, int numEntries)
+        {
+            if (numEntries <= 0)
+            {
+                throw new ArgumentOutOfRangeException("numEntries", "Must be greater than zero.");
+            }
+            int[] array = new int[numEntries];
+            fixed (int* ptr = &array[0])
+            {
+                alSourceUnqueueBuffers(sourceId, numEntries, ptr);
+            }
+            return array;
+        }
+
+        internal static void SourceUnqueueBuffers(int sid, int numENtries, out int[] bids)
+        {
+            alSourceUnqueueBuffers2(sid, numENtries, out bids);
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate int d_algetenumvalue(string enumName);
+        internal static d_algetenumvalue alGetEnumValue = FuncLoader.LoadFunction<d_algetenumvalue>(NativeLibrary, "alGetEnumValue");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate bool d_alisextensionpresent(string extensionName);
+        internal static d_alisextensionpresent IsExtensionPresent = FuncLoader.LoadFunction<d_alisextensionpresent>(NativeLibrary, "alIsExtensionPresent");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate IntPtr d_algetprocaddress(string functionName);
+        internal static d_algetprocaddress alGetProcAddress = FuncLoader.LoadFunction<d_algetprocaddress>(NativeLibrary, "alGetProcAddress");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_algetstring(int p);
+        private static d_algetstring alGetString = FuncLoader.LoadFunction<d_algetstring>(NativeLibrary, "alGetString");
+
+        internal static string GetString(int p)
+        {
+            return Marshal.PtrToStringAnsi(alGetString(p));
+        }
+
+        internal static string Get(ALGetString p)
+        {
+            return GetString((int)p);
+        }
+    }
+
+    internal partial class Alc
+    {
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate IntPtr d_alccreatecontext(IntPtr device, int[] attributes);
+        internal static d_alccreatecontext CreateContext = FuncLoader.LoadFunction<d_alccreatecontext>(AL.NativeLibrary, "alcCreateContext");
+
+        internal static AlcError GetError()
+        {
+            return GetErrorForDevice(IntPtr.Zero);
+        }
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate AlcError d_alcgeterror(IntPtr device);
+        internal static d_alcgeterror GetErrorForDevice = FuncLoader.LoadFunction<d_alcgeterror>(AL.NativeLibrary, "alcGetError");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alcgetintegerv(IntPtr device, int param, int size, int[] values);
+        internal static d_alcgetintegerv alcGetIntegerv = FuncLoader.LoadFunction<d_alcgetintegerv>(AL.NativeLibrary, "alcGetIntegerv");
+
+        internal static void GetInteger(IntPtr device, AlcGetInteger param, int size, int[] values)
+        {
+            alcGetIntegerv(device, (int)param, size, values);
+        }
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate IntPtr d_alcgetcurrentcontext();
+        internal static d_alcgetcurrentcontext GetCurrentContext = FuncLoader.LoadFunction<d_alcgetcurrentcontext>(AL.NativeLibrary, "alcGetCurrentContext");
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alcmakecontextcurrent(IntPtr context);
+        internal static d_alcmakecontextcurrent MakeContextCurrent = FuncLoader.LoadFunction<d_alcmakecontextcurrent>(AL.NativeLibrary, "alcMakeContextCurrent");
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alcdestroycontext(IntPtr context);
+        internal static d_alcdestroycontext DestroyContext = FuncLoader.LoadFunction<d_alcdestroycontext>(AL.NativeLibrary, "alcDestroyContext");
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alcclosedevice(IntPtr device);
+        internal static d_alcclosedevice CloseDevice = FuncLoader.LoadFunction<d_alcclosedevice>(AL.NativeLibrary, "alcCloseDevice");
+
+        [CLSCompliant(false)]
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate IntPtr d_alcopendevice(string device);
+        internal static d_alcopendevice OpenDevice = FuncLoader.LoadFunction<d_alcopendevice>(AL.NativeLibrary, "alcOpenDevice");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate IntPtr d_alccaptureopendevice(string device, uint sampleRate, int format, int sampleSize);
+        internal static d_alccaptureopendevice alcCaptureOpenDevice = FuncLoader.LoadFunction<d_alccaptureopendevice>(AL.NativeLibrary, "alcCaptureOpenDevice");
+
+        internal static IntPtr CaptureOpenDevice(string device, uint sampleRate, ALFormat format, int sampleSize)
+        {
+            return alcCaptureOpenDevice(device, sampleRate, (int)format, sampleSize);
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate IntPtr d_alccapturestart(IntPtr device);
+        internal static d_alccapturestart CaptureStart = FuncLoader.LoadFunction<d_alccapturestart>(AL.NativeLibrary, "alcCaptureStart");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alccapturesamples(IntPtr device, IntPtr buffer, int samples);
+        internal static d_alccapturesamples CaptureSamples = FuncLoader.LoadFunction<d_alccapturesamples>(AL.NativeLibrary, "alcCaptureSamples");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate IntPtr d_alccapturestop(IntPtr device);
+        internal static d_alccapturestop CaptureStop = FuncLoader.LoadFunction<d_alccapturestop>(AL.NativeLibrary, "alcCaptureStop");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate IntPtr d_alccaptureclosedevice(IntPtr device);
+        internal static d_alccaptureclosedevice CaptureCloseDevice = FuncLoader.LoadFunction<d_alccaptureclosedevice>(AL.NativeLibrary, "alcCaptureCloseDevice");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate bool d_alcisextensionpresent(IntPtr device, string extensionName);
+        internal static d_alcisextensionpresent IsExtensionPresent = FuncLoader.LoadFunction<d_alcisextensionpresent>(AL.NativeLibrary, "alcIsExtensionPresent");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate IntPtr d_alcgetstring(IntPtr device, int p);
+        internal static d_alcgetstring alcGetString = FuncLoader.LoadFunction<d_alcgetstring>(AL.NativeLibrary, "alcGetString");
+
+        internal static string GetString(IntPtr device, int p)
+        {
+            return Marshal.PtrToStringAnsi(alcGetString(device, p));
+        }
+
+        internal static string GetString(IntPtr device, AlcGetString p)
+        {
+            return GetString(device, (int)p);
+        }
+
+#if IOS
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alcsuspendcontext(IntPtr context);
+        internal static d_alcsuspendcontext SuspendContext = FuncLoader.LoadFunction<d_alcsuspendcontext>(AL.NativeLibrary, "alcSuspendContext");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alcprocesscontext(IntPtr context);
+        internal static d_alcprocesscontext ProcessContext = FuncLoader.LoadFunction<d_alcprocesscontext>(AL.NativeLibrary, "alcProcessContext");
+#endif
+
+#if ANDROID
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alcdevicepausesoft(IntPtr device);
+        internal static d_alcdevicepausesoft DevicePause = FuncLoader.LoadFunction<d_alcdevicepausesoft>(AL.NativeLibrary, "alcDevicePauseSOFT");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        internal delegate void d_alcdeviceresumesoft(IntPtr device);
+        internal static d_alcdeviceresumesoft DeviceResume = FuncLoader.LoadFunction<d_alcdeviceresumesoft>(AL.NativeLibrary, "alcDeviceResumeSOFT");
+#endif
+    }
+
+    internal class XRamExtension
+    {
+        internal enum XRamStorage
+        {
+            Automatic,
+            Hardware,
+            Accessible
+        }
+
+        private int RamSize;
+        private int RamFree;
+        private int StorageAuto;
+        private int StorageHardware;
+        private int StorageAccessible;
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate bool SetBufferModeDelegate(int n, ref int buffers, int value);
+
+        private SetBufferModeDelegate setBufferMode;
+
+        internal XRamExtension()
+        {
+            IsInitialized = false;
+            if (!AL.IsExtensionPresent("EAX-RAM"))
+            {
+                return;
+            }
+            RamSize = AL.alGetEnumValue("AL_EAX_RAM_SIZE");
+            RamFree = AL.alGetEnumValue("AL_EAX_RAM_FREE");
+            StorageAuto = AL.alGetEnumValue("AL_STORAGE_AUTOMATIC");
+            StorageHardware = AL.alGetEnumValue("AL_STORAGE_HARDWARE");
+            StorageAccessible = AL.alGetEnumValue("AL_STORAGE_ACCESSIBLE");
+            if (RamSize == 0 || RamFree == 0 || StorageAuto == 0 || StorageHardware == 0 || StorageAccessible == 0)
+            {
+                return;
+            }
+            try
+            {
+                setBufferMode = (XRamExtension.SetBufferModeDelegate)Marshal.GetDelegateForFunctionPointer(AL.alGetProcAddress("EAXSetBufferMode"), typeof(XRamExtension.SetBufferModeDelegate));
+            }
+            catch (Exception)
+            {
+                return;
+            }
+            IsInitialized = true;
+        }
+
+        internal bool IsInitialized { get; private set; }
+
+        internal bool SetBufferMode(int i, ref int id, XRamStorage storage)
+        {
+            if (storage == XRamExtension.XRamStorage.Accessible)
+            {
+                return setBufferMode(i, ref id, StorageAccessible);
+            }
+            if (storage != XRamExtension.XRamStorage.Hardware)
+            {
+                return setBufferMode(i, ref id, StorageAuto);
+            }
+            return setBufferMode(i, ref id, StorageHardware);
+        }
+    }
+
+    [CLSCompliant(false)]
+    internal class EffectsExtension
+    {
+        /* Effect API */
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void alGenEffectsDelegate(int n, out uint effect);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void alDeleteEffectsDelegate(int n, ref int effect);
+        //[UnmanagedFunctionPointer (CallingConvention.Cdecl)]
+        //private delegate bool alIsEffectDelegate (uint effect);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void alEffectfDelegate(uint effect, EfxEffectf param, float value);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void alEffectiDelegate(uint effect, EfxEffecti param, int value);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void alGenAuxiliaryEffectSlotsDelegate(int n, out uint effectslots);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void alDeleteAuxiliaryEffectSlotsDelegate(int n, ref int effectslots);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void alAuxiliaryEffectSlotiDelegate(uint slot, EfxEffecti type, uint effect);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void alAuxiliaryEffectSlotfDelegate(uint slot, EfxEffectSlotf param, float value);
+
+        /* Filter API */
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private unsafe delegate void alGenFiltersDelegate(int n, [Out] uint* filters);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void alFilteriDelegate(uint fid, EfxFilteri param, int value);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void alFilterfDelegate(uint fid, EfxFilterf param, float value);
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private unsafe delegate void alDeleteFiltersDelegate(int n, [In] uint* filters);
+
+
+        private alGenEffectsDelegate alGenEffects;
+        private alDeleteEffectsDelegate alDeleteEffects;
+        //private alIsEffectDelegate alIsEffect;
+        private alEffectfDelegate alEffectf;
+        private alEffectiDelegate alEffecti;
+        private alGenAuxiliaryEffectSlotsDelegate alGenAuxiliaryEffectSlots;
+        private alDeleteAuxiliaryEffectSlotsDelegate alDeleteAuxiliaryEffectSlots;
+        private alAuxiliaryEffectSlotiDelegate alAuxiliaryEffectSloti;
+        private alAuxiliaryEffectSlotfDelegate alAuxiliaryEffectSlotf;
+        private alGenFiltersDelegate alGenFilters;
+        private alFilteriDelegate alFilteri;
+        private alFilterfDelegate alFilterf;
+        private alDeleteFiltersDelegate alDeleteFilters;
+
+        internal static IntPtr device;
+        static EffectsExtension _instance;
+        internal static EffectsExtension Instance
+        {
+            get
+            {
+                if (_instance == null)
+                    _instance = new EffectsExtension();
+                return _instance;
+            }
+        }
+
+        internal EffectsExtension()
+        {
+            IsInitialized = false;
+            if (!Alc.IsExtensionPresent(device, "ALC_EXT_EFX"))
+            {
+                return;
+            }
+
+            alGenEffects = (alGenEffectsDelegate)Marshal.GetDelegateForFunctionPointer(AL.alGetProcAddress("alGenEffects"), typeof(alGenEffectsDelegate));
+            alDeleteEffects = (alDeleteEffectsDelegate)Marshal.GetDelegateForFunctionPointer(AL.alGetProcAddress("alDeleteEffects"), typeof(alDeleteEffectsDelegate));
+            alEffectf = (alEffectfDelegate)Marshal.GetDelegateForFunctionPointer(AL.alGetProcAddress("alEffectf"), typeof(alEffectfDelegate));
+            alEffecti = (alEffectiDelegate)Marshal.GetDelegateForFunctionPointer(AL.alGetProcAddress("alEffecti"), typeof(alEffectiDelegate));
+            alGenAuxiliaryEffectSlots = (alGenAuxiliaryEffectSlotsDelegate)Marshal.GetDelegateForFunctionPointer(AL.alGetProcAddress("alGenAuxiliaryEffectSlots"), typeof(alGenAuxiliaryEffectSlotsDelegate));
+            alDeleteAuxiliaryEffectSlots = (alDeleteAuxiliaryEffectSlotsDelegate)Marshal.GetDelegateForFunctionPointer(AL.alGetProcAddress("alDeleteAuxiliaryEffectSlots"), typeof(alDeleteAuxiliaryEffectSlotsDelegate));
+            alAuxiliaryEffectSloti = (alAuxiliaryEffectSlotiDelegate)Marshal.GetDelegateForFunctionPointer(AL.alGetProcAddress("alAuxiliaryEffectSloti"), typeof(alAuxiliaryEffectSlotiDelegate));
+            alAuxiliaryEffectSlotf = (alAuxiliaryEffectSlotfDelegate)Marshal.GetDelegateForFunctionPointer(AL.alGetProcAddress("alAuxiliaryEffectSlotf"), typeof(alAuxiliaryEffectSlotfDelegate));
+
+            alGenFilters = (alGenFiltersDelegate)Marshal.GetDelegateForFunctionPointer(AL.alGetProcAddress("alGenFilters"), typeof(alGenFiltersDelegate));
+            alFilteri = (alFilteriDelegate)Marshal.GetDelegateForFunctionPointer(AL.alGetProcAddress("alFilteri"), typeof(alFilteriDelegate));
+            alFilterf = (alFilterfDelegate)Marshal.GetDelegateForFunctionPointer(AL.alGetProcAddress("alFilterf"), typeof(alFilterfDelegate));
+            alDeleteFilters = (alDeleteFiltersDelegate)Marshal.GetDelegateForFunctionPointer(AL.alGetProcAddress("alDeleteFilters"), typeof(alDeleteFiltersDelegate));
+
+            IsInitialized = true;
+        }
+
+        internal bool IsInitialized { get; private set; }
+
+        /*
+
+alEffecti (effect, EfxEffecti.FilterType, (int)EfxEffectType.Reverb);
+            ALHelper.CheckError ("Failed to set Filter Type.");
+
+        */
+
+        internal void GenAuxiliaryEffectSlots(int count, out uint slot)
+        {
+            this.alGenAuxiliaryEffectSlots(count, out slot);
+            ALHelper.CheckError("Failed to Genereate Aux slot");
+        }
+
+        internal void GenEffect(out uint effect)
+        {
+            this.alGenEffects(1, out effect);
+            ALHelper.CheckError("Failed to Generate Effect.");
+        }
+
+        internal void DeleteAuxiliaryEffectSlot(int slot)
+        {
+            alDeleteAuxiliaryEffectSlots(1, ref slot);
+        }
+
+        internal void DeleteEffect(int effect)
+        {
+            alDeleteEffects(1, ref effect);
+        }
+
+        internal void BindEffectToAuxiliarySlot(uint slot, uint effect)
+        {
+            alAuxiliaryEffectSloti(slot, EfxEffecti.SlotEffect, effect);
+            ALHelper.CheckError("Failed to bind Effect");
+        }
+
+        internal void AuxiliaryEffectSlot(uint slot, EfxEffectSlotf param, float value)
+        {
+            alAuxiliaryEffectSlotf(slot, param, value);
+            ALHelper.CheckError("Failes to set " + param + " " + value);
+        }
+
+        internal void BindSourceToAuxiliarySlot(int SourceId, int slot, int slotnumber, int filter)
+        {
+            AL.alSource3i(SourceId, ALSourcei.EfxAuxilarySendFilter, slot, slotnumber, filter);
+        }
+
+        internal void Effect(uint effect, EfxEffectf param, float value)
+        {
+            alEffectf(effect, param, value);
+            ALHelper.CheckError("Failed to set " + param + " " + value);
+        }
+
+        internal void Effect(uint effect, EfxEffecti param, int value)
+        {
+            alEffecti(effect, param, value);
+            ALHelper.CheckError("Failed to set " + param + " " + value);
+        }
+
+        internal unsafe int GenFilter()
+        {
+            uint filter = 0;
+            this.alGenFilters(1, &filter);
+            return (int)filter;
+        }
+        internal void Filter(int sourceId, EfxFilteri filter, int EfxFilterType)
+        {
+            this.alFilteri((uint)sourceId, filter, EfxFilterType);
+        }
+        internal void Filter(int sourceId, EfxFilterf filter, float EfxFilterType)
+        {
+            this.alFilterf((uint)sourceId, filter, EfxFilterType);
+        }
+        internal void BindFilterToSource(int sourceId, int filterId)
+        {
+            AL.Source(sourceId, ALSourcei.EfxDirectFilter, filterId);
+        }
+        internal unsafe void DeleteFilter(int filterId)
+        {
+            alDeleteFilters(1, (uint*)&filterId);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Audio/OpenALSoundController.cs b/MonoGame.Framework/Audio/OpenALSoundController.cs
new file mode 100644
index 00000000000..c404cb2bf58
--- /dev/null
+++ b/MonoGame.Framework/Audio/OpenALSoundController.cs
@@ -0,0 +1,469 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.IO;
+using System.Runtime.InteropServices;
+using MonoGame.Utilities;
+using MonoGame.OpenAL;
+using MonoGame.OpenGL;
+
+#if ANDROID
+using System.Globalization;
+using Android.Content.PM;
+using Android.Content;
+using Android.Media;
+#endif
+
+#if IOS
+using AudioToolbox;
+using AVFoundation;
+#endif
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    internal static class ALHelper
+    {
+        [System.Diagnostics.Conditional("DEBUG")]
+        [System.Diagnostics.DebuggerHidden]
+        internal static void CheckError(string message = "", params object[] args)
+        {
+            ALError error;
+            if ((error = AL.GetError()) != ALError.NoError)
+            {
+                if (args != null && args.Length > 0)
+                    message = String.Format(message, args);
+                
+                throw new InvalidOperationException(message + " (Reason: " + AL.GetErrorString(error) + ")");
+            }
+        }
+
+        public static bool IsStereoFormat(ALFormat format)
+        {
+            return (format == ALFormat.Stereo8
+                || format == ALFormat.Stereo16
+                || format == ALFormat.StereoFloat32
+                || format == ALFormat.StereoIma4
+                || format == ALFormat.StereoMSAdpcm);
+        }
+    }
+
+    internal static class AlcHelper
+    {
+        [System.Diagnostics.Conditional("DEBUG")]
+        [System.Diagnostics.DebuggerHidden]
+        internal static void CheckError(string message = "", params object[] args)
+        {
+            AlcError error;
+            if ((error = Alc.GetError()) != AlcError.NoError)
+            {
+                if (args != null && args.Length > 0)
+                    message = String.Format(message, args);
+
+                throw new InvalidOperationException(message + " (Reason: " + error.ToString() + ")");
+            }
+        }
+    }
+
+    internal sealed class OpenALSoundController : IDisposable
+    {
+        private static OpenALSoundController _instance = null;
+        private static EffectsExtension _efx = null;
+        private IntPtr _device;
+        private IntPtr _context;
+        IntPtr NullContext = IntPtr.Zero;
+        private int[] allSourcesArray;
+#if DESKTOPGL || ANGLE
+
+        // MacOS & Linux shares a limit of 256.
+        internal const int MAX_NUMBER_OF_SOURCES = 256;
+
+#elif IOS
+
+        // Reference: http://stackoverflow.com/questions/3894044/maximum-number-of-openal-sound-buffers-on-iphone
+        internal const int MAX_NUMBER_OF_SOURCES = 32;
+
+#elif ANDROID
+
+        // Set to the same as OpenAL on iOS
+        internal const int MAX_NUMBER_OF_SOURCES = 32;
+
+#endif
+#if ANDROID
+        private const int DEFAULT_FREQUENCY = 48000;
+        private const int DEFAULT_UPDATE_SIZE = 512;
+        private const int DEFAULT_UPDATE_BUFFER_COUNT = 2;
+#elif DESKTOPGL
+        private static OggStreamer _oggstreamer;
+#endif
+        private List<int> availableSourcesCollection;
+        private List<int> inUseSourcesCollection;
+        bool _isDisposed;
+        public bool SupportsIma4 { get; private set; }
+        public bool SupportsAdpcm { get; private set; }
+        public bool SupportsEfx { get; private set; }
+        public bool SupportsIeee { get; private set; }
+
+        /// <summary>
+        /// Sets up the hardware resources used by the controller.
+        /// </summary>
+		private OpenALSoundController()
+        {
+            if (AL.NativeLibrary == IntPtr.Zero)
+                throw new DllNotFoundException("Couldn't initialize OpenAL because the native binaries couldn't be found.");
+
+            if (!OpenSoundController())
+            {
+                throw new NoAudioHardwareException("OpenAL device could not be initialized, see console output for details.");
+            }
+
+            if (Alc.IsExtensionPresent(_device, "ALC_EXT_CAPTURE"))
+                Microphone.PopulateCaptureDevices();
+
+            // We have hardware here and it is ready
+
+			allSourcesArray = new int[MAX_NUMBER_OF_SOURCES];
+			AL.GenSources(allSourcesArray);
+            ALHelper.CheckError("Failed to generate sources.");
+            Filter = 0;
+            if (Efx.IsInitialized)
+            {
+                Filter = Efx.GenFilter();
+            }
+            availableSourcesCollection = new List<int>(allSourcesArray);
+			inUseSourcesCollection = new List<int>();
+		}
+
+        ~OpenALSoundController()
+        {
+            Dispose(false);
+        }
+
+        /// <summary>
+        /// Open the sound device, sets up an audio context, and makes the new context
+        /// the current context. Note that this method will stop the playback of
+        /// music that was running prior to the game start. If any error occurs, then
+        /// the state of the controller is reset.
+        /// </summary>
+        /// <returns>True if the sound controller was setup, and false if not.</returns>
+        private bool OpenSoundController()
+        {
+            try
+            {
+                _device = Alc.OpenDevice(string.Empty);
+                EffectsExtension.device = _device;
+            }
+            catch (Exception ex)
+            {
+                throw new NoAudioHardwareException("OpenAL device could not be initialized.", ex);
+            }
+
+            AlcHelper.CheckError("Could not open OpenAL device");
+
+            if (_device != IntPtr.Zero)
+            {
+#if ANDROID
+                // Attach activity event handlers so we can pause and resume all playing sounds
+                MonoGameAndroidGameView.OnPauseGameThread += Activity_Paused;
+                MonoGameAndroidGameView.OnResumeGameThread += Activity_Resumed;
+
+                // Query the device for the ideal frequency and update buffer size so
+                // we can get the low latency sound path.
+
+                /*
+                The recommended sequence is:
+
+                Check for feature "android.hardware.audio.low_latency" using code such as this:
+                import android.content.pm.PackageManager;
+                ...
+                PackageManager pm = getContext().getPackageManager();
+                boolean claimsFeature = pm.hasSystemFeature(PackageManager.FEATURE_AUDIO_LOW_LATENCY);
+                Check for API level 17 or higher, to confirm use of android.media.AudioManager.getProperty().
+                Get the native or optimal output sample rate and buffer size for this device's primary output stream, using code such as this:
+                import android.media.AudioManager;
+                ...
+                AudioManager am = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
+                String sampleRate = am.getProperty(AudioManager.PROPERTY_OUTPUT_SAMPLE_RATE));
+                String framesPerBuffer = am.getProperty(AudioManager.PROPERTY_OUTPUT_FRAMES_PER_BUFFER));
+                Note that sampleRate and framesPerBuffer are Strings. First check for null and then convert to int using Integer.parseInt().
+                Now use OpenSL ES to create an AudioPlayer with PCM buffer queue data locator.
+
+                See http://stackoverflow.com/questions/14842803/low-latency-audio-playback-on-android
+                */
+
+                int frequency = DEFAULT_FREQUENCY;
+                int updateSize = DEFAULT_UPDATE_SIZE;
+                int updateBuffers = DEFAULT_UPDATE_BUFFER_COUNT;
+                if (Android.OS.Build.VERSION.SdkInt >= Android.OS.BuildVersionCodes.JellyBeanMr1)
+                {
+                    Android.Util.Log.Debug("OAL", Game.Activity.PackageManager.HasSystemFeature(PackageManager.FeatureAudioLowLatency) ? "Supports low latency audio playback." : "Does not support low latency audio playback.");
+
+                    var audioManager = Game.Activity.GetSystemService(Context.AudioService) as AudioManager;
+                    if (audioManager != null)
+                    {
+                        var result = audioManager.GetProperty(AudioManager.PropertyOutputSampleRate);
+                        if (!string.IsNullOrEmpty(result))
+                            frequency = int.Parse(result, CultureInfo.InvariantCulture);
+                        result = audioManager.GetProperty(AudioManager.PropertyOutputFramesPerBuffer);
+                        if (!string.IsNullOrEmpty(result))
+                            updateSize = int.Parse(result, CultureInfo.InvariantCulture);
+                    }
+
+                    // If 4.4 or higher, then we don't need to double buffer on the application side.
+                    // See http://stackoverflow.com/a/15006327
+                    if (Android.OS.Build.VERSION.SdkInt >= Android.OS.BuildVersionCodes.Kitkat)
+                    {
+                        updateBuffers = 1;
+                    }
+                }
+                else
+                {
+                    Android.Util.Log.Debug("OAL", "Android 4.2 or higher required for low latency audio playback.");
+                }
+                Android.Util.Log.Debug("OAL", "Using sample rate " + frequency + "Hz and " + updateBuffers + " buffers of " + updateSize + " frames.");
+
+                // These are missing and non-standard ALC constants
+                const int AlcFrequency = 0x1007;
+                const int AlcUpdateSize = 0x1014;
+                const int AlcUpdateBuffers = 0x1015;
+
+                int[] attribute = new[]
+                {
+                    AlcFrequency, frequency,
+                    AlcUpdateSize, updateSize,
+                    AlcUpdateBuffers, updateBuffers,
+                    0
+                };
+#elif IOS
+                AVAudioSession.SharedInstance().Init();
+
+                // NOTE: Do not override AVAudioSessionCategory set by the game developer:
+                //       see https://github.com/MonoGame/MonoGame/issues/6595
+
+                EventHandler<AVAudioSessionInterruptionEventArgs> handler = delegate(object sender, AVAudioSessionInterruptionEventArgs e) {
+                    switch (e.InterruptionType)
+                    {
+                        case AVAudioSessionInterruptionType.Began:
+                            AVAudioSession.SharedInstance().SetActive(false);
+                            Alc.MakeContextCurrent(IntPtr.Zero);
+                            Alc.SuspendContext(_context);
+                            break;
+                        case AVAudioSessionInterruptionType.Ended:
+                            AVAudioSession.SharedInstance().SetActive(true);
+                            Alc.MakeContextCurrent(_context);
+                            Alc.ProcessContext(_context);
+                            break;
+                    }
+                };
+
+                AVAudioSession.Notifications.ObserveInterruption(handler);
+
+                // Activate the instance or else the interruption handler will not be called.
+                AVAudioSession.SharedInstance().SetActive(true);
+
+                int[] attribute = new int[0];
+#else
+                int[] attribute = new int[0];
+#endif
+
+                _context = Alc.CreateContext(_device, attribute);
+#if DESKTOPGL
+                _oggstreamer = new OggStreamer();
+#endif
+
+                AlcHelper.CheckError("Could not create OpenAL context");
+
+                if (_context != NullContext)
+                {
+                    Alc.MakeContextCurrent(_context);
+                    AlcHelper.CheckError("Could not make OpenAL context current");
+                    SupportsIma4 = AL.IsExtensionPresent("AL_EXT_IMA4");
+                    SupportsAdpcm = AL.IsExtensionPresent("AL_SOFT_MSADPCM");
+                    SupportsEfx = AL.IsExtensionPresent("AL_EXT_EFX");
+                    SupportsIeee = AL.IsExtensionPresent("AL_EXT_float32");
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public static void EnsureInitialized()
+        {
+            if (_instance == null)
+            {
+                try
+                {
+                    _instance = new OpenALSoundController();
+                }
+                catch (DllNotFoundException)
+                {
+                    throw;
+                }
+                catch (NoAudioHardwareException)
+                {
+                    throw;
+                }
+                catch (Exception ex)
+                {
+                    throw (new NoAudioHardwareException("Failed to init OpenALSoundController", ex));
+                }
+            }
+        }
+
+
+        public static OpenALSoundController Instance
+        {
+			get
+            {
+                if (_instance == null)
+                    throw new NoAudioHardwareException("OpenAL context has failed to initialize. Call SoundEffect.Initialize() before sound operation to get more specific errors.");
+				return _instance;
+			}
+		}
+
+        public static EffectsExtension Efx
+        {
+            get
+            {
+                if (_efx == null)
+                    _efx = new EffectsExtension();
+                return _efx;
+            }
+        }
+
+        public int Filter
+        {
+            get; private set;
+        }
+
+        public static void DestroyInstance()
+        {
+            if (_instance != null)
+            {
+                _instance.Dispose();
+                _instance = null;
+            }
+        }
+
+        /// <summary>
+        /// Destroys the AL context and closes the device, when they exist.
+        /// </summary>
+        private void CleanUpOpenAL()
+        {
+            Alc.MakeContextCurrent(NullContext);
+
+            if (_context != NullContext)
+            {
+                Alc.DestroyContext (_context);
+                _context = NullContext;
+            }
+            if (_device != IntPtr.Zero)
+            {
+                Alc.CloseDevice (_device);
+                _device = IntPtr.Zero;
+            }
+        }
+
+        /// <summary>
+        /// Dispose of the OpenALSoundCOntroller.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Dispose of the OpenALSoundCOntroller.
+        /// </summary>
+        /// <param name="disposing">If true, the managed resources are to be disposed.</param>
+		void Dispose(bool disposing)
+		{
+            if (!_isDisposed)
+            {
+                if (disposing)
+                {
+#if DESKTOPGL
+                    if(_oggstreamer != null)
+                        _oggstreamer.Dispose();
+#endif
+                    for (int i = 0; i < allSourcesArray.Length; i++)
+                    {
+                        AL.DeleteSource(allSourcesArray[i]);
+                        ALHelper.CheckError("Failed to delete source.");
+                    }
+
+                    if (Filter != 0 && Efx.IsInitialized)
+                        Efx.DeleteFilter(Filter);
+
+                    Microphone.StopMicrophones();
+                    CleanUpOpenAL();                    
+                }
+                _isDisposed = true;
+            }
+		}
+
+        /// <summary>
+        /// Reserves a sound buffer and return its identifier. If there are no available sources
+        /// or the controller was not able to setup the hardware then an
+        /// <see cref="InstancePlayLimitException"/> is thrown.
+        /// </summary>
+        /// <returns>The source number of the reserved sound buffer.</returns>
+		public int ReserveSource()
+		{
+            int sourceNumber;
+
+            lock (availableSourcesCollection)
+            {                
+                if (availableSourcesCollection.Count == 0)
+                {
+                    throw new InstancePlayLimitException();
+                }
+
+                sourceNumber = availableSourcesCollection.Last();
+                inUseSourcesCollection.Add(sourceNumber);
+                availableSourcesCollection.Remove(sourceNumber);
+            }
+
+            return sourceNumber;
+		}
+
+        public void RecycleSource(int sourceId)
+		{
+            lock (availableSourcesCollection)
+            {
+                inUseSourcesCollection.Remove(sourceId);
+                availableSourcesCollection.Add(sourceId);
+            }
+		}
+
+        public void FreeSource(SoundEffectInstance inst)
+        {
+            RecycleSource(inst.SourceId);
+            inst.SourceId = 0;
+            inst.HasSourceId = false;
+            inst.SoundState = SoundState.Stopped;
+		}
+
+        public double SourceCurrentPosition (int sourceId)
+		{
+            int pos;
+			AL.GetSource (sourceId, ALGetSourcei.SampleOffset, out pos);
+            ALHelper.CheckError("Failed to set source offset.");
+			return pos;
+		}
+
+#if ANDROID
+        void Activity_Paused(object sender, EventArgs e)
+        {
+            // Pause all currently playing sounds by pausing the mixer
+            Alc.DevicePause(_device);
+        }
+
+        void Activity_Resumed(object sender, EventArgs e)
+        {
+            // Resume all sounds that were playing when the activity was paused
+            Alc.DeviceResume(_device);
+        }
+#endif
+    }
+}
diff --git a/MonoGame.Framework/Audio/SoundEffect.OpenAL.cs b/MonoGame.Framework/Audio/SoundEffect.OpenAL.cs
new file mode 100644
index 00000000000..429ca15f28d
--- /dev/null
+++ b/MonoGame.Framework/Audio/SoundEffect.OpenAL.cs
@@ -0,0 +1,254 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+#if OPENAL
+using MonoGame.OpenAL;
+#endif
+#if IOS
+using AudioToolbox;
+using AudioUnit;
+#endif
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    public sealed partial class SoundEffect : IDisposable
+    {
+        internal const int MAX_PLAYING_INSTANCES = OpenALSoundController.MAX_NUMBER_OF_SOURCES;
+        internal static uint ReverbSlot = 0;
+        internal static uint ReverbEffect = 0;
+
+        internal OALSoundBuffer SoundBuffer;
+
+        #region Public Constructors
+
+        private void PlatformLoadAudioStream(Stream stream, out TimeSpan duration)
+        {
+            byte[] buffer;
+
+            ALFormat format;
+            int freq;
+            int channels;
+            int blockAlignment;
+            int bitsPerSample;
+            int samplesPerBlock;
+            int sampleCount;
+            buffer = AudioLoader.Load(stream, out format, out freq, out channels, out blockAlignment, out bitsPerSample, out samplesPerBlock, out sampleCount);
+
+            duration = TimeSpan.FromSeconds((float)sampleCount / (float)freq);
+
+            PlatformInitializeBuffer(buffer, buffer.Length, format, channels, freq, blockAlignment, bitsPerSample, 0, 0);
+        }
+
+        private void PlatformInitializePcm(byte[] buffer, int offset, int count, int sampleBits, int sampleRate, AudioChannels channels, int loopStart, int loopLength)
+        {
+            if (sampleBits == 24)
+            {
+                // Convert 24-bit signed PCM to 16-bit signed PCM
+                buffer = AudioLoader.Convert24To16(buffer, offset, count);
+                offset = 0;
+                count = buffer.Length;
+                sampleBits = 16;
+            }
+
+            var format = AudioLoader.GetSoundFormat(AudioLoader.FormatPcm, (int)channels, sampleBits);
+
+            // bind buffer
+            SoundBuffer = new OALSoundBuffer();
+            SoundBuffer.BindDataBuffer(buffer, format, count, sampleRate);
+        }
+
+        private void PlatformInitializeIeeeFloat(byte[] buffer, int offset, int count, int sampleRate, AudioChannels channels, int loopStart, int loopLength)
+        {
+            if (!OpenALSoundController.Instance.SupportsIeee)
+            {
+                // If 32-bit IEEE float is not supported, convert to 16-bit signed PCM
+                buffer = AudioLoader.ConvertFloatTo16(buffer, offset, count);
+                PlatformInitializePcm(buffer, 0, buffer.Length, 16, sampleRate, channels, loopStart, loopLength);
+                return;
+            }
+
+            var format = AudioLoader.GetSoundFormat(AudioLoader.FormatIeee, (int)channels, 32);
+
+            // bind buffer
+            SoundBuffer = new OALSoundBuffer();
+            SoundBuffer.BindDataBuffer(buffer, format, count, sampleRate);
+        }
+
+        private void PlatformInitializeAdpcm(byte[] buffer, int offset, int count, int sampleRate, AudioChannels channels, int blockAlignment, int loopStart, int loopLength)
+        {
+            if (!OpenALSoundController.Instance.SupportsAdpcm)
+            {
+                // If MS-ADPCM is not supported, convert to 16-bit signed PCM
+                buffer = AudioLoader.ConvertMsAdpcmToPcm(buffer, offset, count, (int)channels, blockAlignment);
+                PlatformInitializePcm(buffer, 0, buffer.Length, 16, sampleRate, channels, loopStart, loopLength);
+                return;
+            }
+
+            var format = AudioLoader.GetSoundFormat(AudioLoader.FormatMsAdpcm, (int)channels, 0);
+            int sampleAlignment = AudioLoader.SampleAlignment(format, blockAlignment);
+
+            // bind buffer
+            SoundBuffer = new OALSoundBuffer();
+            // Buffer length must be aligned with the block alignment
+            int alignedCount = count - (count % blockAlignment);
+            SoundBuffer.BindDataBuffer(buffer, format, alignedCount, sampleRate, sampleAlignment);
+        }
+
+        private void PlatformInitializeIma4(byte[] buffer, int offset, int count, int sampleRate, AudioChannels channels, int blockAlignment, int loopStart, int loopLength)
+        {
+            if (!OpenALSoundController.Instance.SupportsIma4)
+            {
+                // If IMA/ADPCM is not supported, convert to 16-bit signed PCM
+                buffer = AudioLoader.ConvertIma4ToPcm(buffer, offset, count, (int)channels, blockAlignment);
+                PlatformInitializePcm(buffer, 0, buffer.Length, 16, sampleRate, channels, loopStart, loopLength);
+                return;
+            }
+
+            var format = AudioLoader.GetSoundFormat(AudioLoader.FormatIma4, (int)channels, 0);
+            int sampleAlignment = AudioLoader.SampleAlignment(format, blockAlignment);
+
+            // bind buffer
+            SoundBuffer = new OALSoundBuffer();
+            SoundBuffer.BindDataBuffer(buffer, format, count, sampleRate, sampleAlignment);
+        }
+
+        private void PlatformInitializeFormat(byte[] header, byte[] buffer, int bufferSize, int loopStart, int loopLength)
+        {
+            var wavFormat = BitConverter.ToInt16(header, 0);
+            var channels = BitConverter.ToInt16(header, 2);
+            var sampleRate = BitConverter.ToInt32(header, 4);
+            var blockAlignment = BitConverter.ToInt16(header, 12);
+            var bitsPerSample = BitConverter.ToInt16(header, 14);
+
+            var format = AudioLoader.GetSoundFormat(wavFormat, channels, bitsPerSample);
+            PlatformInitializeBuffer(buffer, bufferSize, format, channels, sampleRate, blockAlignment, bitsPerSample, loopStart, loopLength);
+        }
+
+        private void PlatformInitializeBuffer(byte[] buffer, int bufferSize, ALFormat format, int channels, int sampleRate, int blockAlignment, int bitsPerSample, int loopStart, int loopLength)
+        {
+            switch (format)
+            {
+                case ALFormat.Mono8:
+                case ALFormat.Mono16:
+                case ALFormat.Stereo8:
+                case ALFormat.Stereo16:
+                    PlatformInitializePcm(buffer, 0, bufferSize, bitsPerSample, sampleRate, (AudioChannels)channels, loopStart, loopLength);
+                    break;
+                case ALFormat.MonoMSAdpcm:
+                case ALFormat.StereoMSAdpcm:
+                    PlatformInitializeAdpcm(buffer, 0, bufferSize, sampleRate, (AudioChannels)channels, blockAlignment, loopStart, loopLength);
+                    break;
+                case ALFormat.MonoFloat32:
+                case ALFormat.StereoFloat32:
+                    PlatformInitializeIeeeFloat(buffer, 0, bufferSize, sampleRate, (AudioChannels)channels, loopStart, loopLength);
+                    break;
+                case ALFormat.MonoIma4:
+                case ALFormat.StereoIma4:
+                    PlatformInitializeIma4(buffer, 0, bufferSize, sampleRate, (AudioChannels)channels, blockAlignment, loopStart, loopLength);
+                    break;
+                default:
+                    throw new NotSupportedException("Unsupported wave format!");
+            }
+        }
+
+        private void PlatformInitializeXact(MiniFormatTag codec, byte[] buffer, int channels, int sampleRate, int blockAlignment, int loopStart, int loopLength, out TimeSpan duration)
+        {
+            if (codec == MiniFormatTag.Adpcm)
+            {
+                PlatformInitializeAdpcm(buffer, 0, buffer.Length, sampleRate, (AudioChannels)channels, (blockAlignment + 16) * channels, loopStart, loopLength);
+                duration = TimeSpan.FromSeconds(SoundBuffer.Duration);
+                return;
+            }
+
+            throw new NotSupportedException("Unsupported sound format!");
+        }
+
+        #endregion
+
+        #region Additional SoundEffect/SoundEffectInstance Creation Methods
+
+        private void PlatformSetupInstance(SoundEffectInstance inst)
+        {
+            inst.InitializeSound();
+        }
+
+        #endregion
+
+        internal static void PlatformSetReverbSettings(ReverbSettings reverbSettings)
+        {
+            if (!OpenALSoundController.Efx.IsInitialized)
+                return;
+
+            if (ReverbEffect != 0)
+                return;
+            
+            var efx = OpenALSoundController.Efx;
+            efx.GenAuxiliaryEffectSlots (1, out ReverbSlot);
+            efx.GenEffect (out ReverbEffect);
+            efx.Effect (ReverbEffect, EfxEffecti.EffectType, (int)EfxEffectType.Reverb);
+            efx.Effect (ReverbEffect, EfxEffectf.EaxReverbReflectionsDelay, reverbSettings.ReflectionsDelayMs / 1000.0f);
+            efx.Effect (ReverbEffect, EfxEffectf.LateReverbDelay, reverbSettings.ReverbDelayMs / 1000.0f);
+            // map these from range 0-15 to 0-1
+            efx.Effect (ReverbEffect, EfxEffectf.EaxReverbDiffusion, reverbSettings.EarlyDiffusion / 15f);
+            efx.Effect (ReverbEffect, EfxEffectf.EaxReverbDiffusion, reverbSettings.LateDiffusion / 15f);
+            efx.Effect (ReverbEffect, EfxEffectf.EaxReverbGainLF, Math.Min (XactHelpers.ParseVolumeFromDecibels (reverbSettings.LowEqGain - 8f), 1.0f));
+            efx.Effect (ReverbEffect, EfxEffectf.EaxReverbLFReference, (reverbSettings.LowEqCutoff * 50f) + 50f);
+            efx.Effect (ReverbEffect, EfxEffectf.EaxReverbGainHF, XactHelpers.ParseVolumeFromDecibels (reverbSettings.HighEqGain - 8f));
+            efx.Effect (ReverbEffect, EfxEffectf.EaxReverbHFReference, (reverbSettings.HighEqCutoff * 500f) + 1000f);
+            // According to Xamarin docs EaxReverbReflectionsGain Unit: Linear gain Range [0.0f .. 3.16f] Default: 0.05f
+            efx.Effect (ReverbEffect, EfxEffectf.EaxReverbReflectionsGain, Math.Min (XactHelpers.ParseVolumeFromDecibels (reverbSettings.ReflectionsGainDb), 3.16f));
+            efx.Effect (ReverbEffect, EfxEffectf.EaxReverbGain, Math.Min (XactHelpers.ParseVolumeFromDecibels (reverbSettings.ReverbGainDb), 1.0f));
+            // map these from 0-100 down to 0-1
+            efx.Effect (ReverbEffect, EfxEffectf.EaxReverbDensity, reverbSettings.DensityPct / 100f);
+            efx.AuxiliaryEffectSlot (ReverbSlot, EfxEffectSlotf.EffectSlotGain, reverbSettings.WetDryMixPct / 200f);
+
+            // Dont know what to do with these EFX has no mapping for them. Just ignore for now
+            // we can enable them as we go. 
+            //efx.SetEffectParam (ReverbEffect, EfxEffectf.PositionLeft, reverbSettings.PositionLeft);
+            //efx.SetEffectParam (ReverbEffect, EfxEffectf.PositionRight, reverbSettings.PositionRight);
+            //efx.SetEffectParam (ReverbEffect, EfxEffectf.PositionLeftMatrix, reverbSettings.PositionLeftMatrix);
+            //efx.SetEffectParam (ReverbEffect, EfxEffectf.PositionRightMatrix, reverbSettings.PositionRightMatrix);
+            //efx.SetEffectParam (ReverbEffect, EfxEffectf.LowFrequencyReference, reverbSettings.RearDelayMs);
+            //efx.SetEffectParam (ReverbEffect, EfxEffectf.LowFrequencyReference, reverbSettings.RoomFilterFrequencyHz);
+            //efx.SetEffectParam (ReverbEffect, EfxEffectf.LowFrequencyReference, reverbSettings.RoomFilterMainDb);
+            //efx.SetEffectParam (ReverbEffect, EfxEffectf.LowFrequencyReference, reverbSettings.RoomFilterHighFrequencyDb);
+            //efx.SetEffectParam (ReverbEffect, EfxEffectf.LowFrequencyReference, reverbSettings.DecayTimeSec);
+            //efx.SetEffectParam (ReverbEffect, EfxEffectf.LowFrequencyReference, reverbSettings.RoomSizeFeet);
+
+            efx.BindEffectToAuxiliarySlot (ReverbSlot, ReverbEffect);
+        }
+
+#region IDisposable Members
+
+        private void PlatformDispose(bool disposing)
+        {
+            if (SoundBuffer != null)
+            {
+                SoundBuffer.Dispose();
+                SoundBuffer = null;
+            }
+        }
+
+#endregion
+
+        internal static void PlatformInitialize()
+        {
+            OpenALSoundController.EnsureInitialized();
+        }
+
+        internal static void PlatformShutdown()
+        {
+            if (ReverbEffect != 0)
+            {
+                OpenALSoundController.Efx.DeleteAuxiliaryEffectSlot((int)ReverbSlot);
+                OpenALSoundController.Efx.DeleteEffect((int)ReverbEffect);
+            }
+            OpenALSoundController.DestroyInstance();
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/SoundEffect.Web.cs b/MonoGame.Framework/Audio/SoundEffect.Web.cs
new file mode 100644
index 00000000000..bb1e6c46a44
--- /dev/null
+++ b/MonoGame.Framework/Audio/SoundEffect.Web.cs
@@ -0,0 +1,59 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+using Microsoft.Xna;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Audio;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    public sealed partial class SoundEffect : IDisposable
+    {
+        // This platform is only limited by memory.
+        internal const int MAX_PLAYING_INSTANCES = int.MaxValue;
+
+        private void PlatformLoadAudioStream(Stream s, out TimeSpan duration)
+        {
+            duration = TimeSpan.Zero;
+        }
+
+        private void PlatformInitializePcm(byte[] buffer, int offset, int count, int sampleBits, int sampleRate, AudioChannels channels, int loopStart, int loopLength)
+        {
+        }
+
+        private void PlatformInitializeFormat(byte[] header, byte[] buffer, int bufferSize, int loopStart, int loopLength)
+        {
+        }
+
+        private void PlatformInitializeXact(MiniFormatTag codec, byte[] buffer, int channels, int sampleRate, int blockAlignment, int loopStart, int loopLength, out TimeSpan duration)
+        {
+            throw new NotSupportedException("Unsupported sound format!");
+        }
+
+        private void PlatformSetupInstance(SoundEffectInstance instance)
+        {
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+        }
+
+        internal static void PlatformSetReverbSettings(ReverbSettings reverbSettings)
+        {
+        }
+
+        internal static void PlatformInitialize()
+        {
+        }
+
+        internal static void PlatformShutdown()
+        {
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/SoundEffect.XAudio.cs b/MonoGame.Framework/Audio/SoundEffect.XAudio.cs
new file mode 100644
index 00000000000..18c57fc90c5
--- /dev/null
+++ b/MonoGame.Framework/Audio/SoundEffect.XAudio.cs
@@ -0,0 +1,384 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+using SharpDX;
+using SharpDX.XAudio2;
+using SharpDX.Multimedia;
+using SharpDX.X3DAudio;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    partial class SoundEffect
+    {
+        // These platforms are only limited by memory.
+        internal const int MAX_PLAYING_INSTANCES = int.MaxValue;
+
+        #region Static Fields & Properties
+
+        internal static XAudio2 Device { get; private set; }
+        internal static MasteringVoice MasterVoice { get; private set; }
+
+        private static X3DAudio _device3D;
+        private static bool _device3DDirty = true;
+        private static Speakers _speakers = Speakers.Stereo;
+
+        // XNA does not expose this, but it exists in X3DAudio.
+        [CLSCompliant(false)]
+        public static Speakers Speakers
+        {
+            get { return _speakers; }
+
+            set
+            {
+                if (_speakers == value)
+                    return;
+                
+                _speakers = value;
+                _device3DDirty = true;
+            }
+        }
+
+        internal static X3DAudio Device3D
+        {
+            get
+            {
+                if (_device3DDirty)
+                {
+                    _device3DDirty = false;
+                    _device3D = new X3DAudio(_speakers);
+                }
+
+                return _device3D;
+            }
+        }
+
+
+        private static SubmixVoice _reverbVoice;
+
+        internal static SubmixVoice ReverbVoice
+        {
+            get
+            {
+                if (_reverbVoice == null)
+                {
+                    var details = MasterVoice.VoiceDetails;
+                    _reverbVoice = new SubmixVoice(Device, details.InputChannelCount, details.InputSampleRate);
+
+                    var reverb = new SharpDX.XAudio2.Fx.Reverb(Device);
+                    var desc = new EffectDescriptor(reverb);
+                    desc.InitialState = true;
+                    desc.OutputChannelCount = details.InputChannelCount;
+                    _reverbVoice.SetEffectChain(desc);
+                }
+
+                return _reverbVoice;
+            }
+        }
+
+        #endregion
+
+        internal DataStream _dataStream;
+        internal AudioBuffer _buffer;
+        internal AudioBuffer _loopedBuffer;
+        internal WaveFormat _format;
+
+        #region Initialization
+
+        /// <summary>
+        /// Initializes XAudio.
+        /// </summary>
+        internal static void PlatformInitialize()
+        {
+            try
+            {
+                if (Device == null)
+                {
+#if !WINDOWS_UAP && DEBUG
+                    try
+                    {
+                        //Fails if the XAudio2 SDK is not installed
+                        Device = new XAudio2(XAudio2Flags.DebugEngine, ProcessorSpecifier.DefaultProcessor);
+                        Device.StartEngine();
+                    }
+                    catch
+#endif
+                    {
+                        Device = new XAudio2(XAudio2Flags.None, ProcessorSpecifier.DefaultProcessor);
+                        Device.StartEngine();
+                    }
+                }
+
+                // Just use the default device.
+#if WINDOWS_UAP
+                string deviceId = null;
+#else
+                const int deviceId = 0;
+#endif
+
+                if (MasterVoice == null)
+                {
+                    // Let windows autodetect number of channels and sample rate.
+                    MasterVoice = new MasteringVoice(Device, XAudio2.DefaultChannels, XAudio2.DefaultSampleRate);
+                }
+
+                // The autodetected value of MasterVoice.ChannelMask corresponds to the speaker layout.
+#if WINDOWS_UAP
+                Speakers = (Speakers)MasterVoice.ChannelMask;
+#else
+                Speakers = Device.Version == XAudio2Version.Version27 ?
+                    Device.GetDeviceDetails(deviceId).OutputFormat.ChannelMask:
+                    (Speakers) MasterVoice.ChannelMask;
+#endif
+            }
+            catch
+            {
+                // Release the device and null it as
+                // we have no audio support.
+                if (Device != null)
+                {
+                    Device.Dispose();
+                    Device = null;
+                }
+
+                MasterVoice = null;
+            }
+        }
+
+        private static DataStream ToDataStream(int offset, byte[] buffer, int length)
+        {
+            // NOTE: We make a copy here because old versions of 
+            // DataStream.Create didn't work correctly for offsets.
+            var data = new byte[length - offset];
+            Buffer.BlockCopy(buffer, offset, data, 0, length - offset);
+
+            return DataStream.Create(data, true, false);
+        }
+
+        private void PlatformInitializePcm(byte[] buffer, int offset, int count, int sampleBits, int sampleRate, AudioChannels channels, int loopStart, int loopLength)
+        {
+            CreateBuffers(  new WaveFormat(sampleRate, sampleBits, (int)channels),
+                            ToDataStream(offset, buffer, count),
+                            loopStart, 
+                            loopLength);
+        }
+
+        private void PlatformInitializeFormat(byte[] header, byte[] buffer, int bufferSize, int loopStart, int loopLength)
+        {
+            var format = BitConverter.ToInt16(header, 0);
+            var channels = BitConverter.ToInt16(header, 2);
+            var sampleRate = BitConverter.ToInt32(header, 4);
+            var blockAlignment = BitConverter.ToInt16(header, 12);
+            var sampleBits = BitConverter.ToInt16(header, 14);
+
+            WaveFormat waveFormat;
+            if (format == 1)
+                waveFormat = new WaveFormat(sampleRate, sampleBits, channels);
+            else if (format == 2)
+                waveFormat = new WaveFormatAdpcm(sampleRate, channels, blockAlignment);
+            else if (format == 3)
+                waveFormat = WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, channels);
+            else
+                throw new NotSupportedException("Unsupported wave format!");
+
+            CreateBuffers(  waveFormat,
+                            ToDataStream(0, buffer, bufferSize),
+                            loopStart,
+                            loopLength);
+        }
+
+        private void PlatformInitializeXact(MiniFormatTag codec, byte[] buffer, int channels, int sampleRate, int blockAlignment, int loopStart, int loopLength, out TimeSpan duration)
+        {
+            if (codec == MiniFormatTag.Adpcm)
+            {
+                duration = TimeSpan.FromSeconds((float)loopLength / sampleRate);
+
+                CreateBuffers(  new WaveFormatAdpcm(sampleRate, channels, blockAlignment),
+                                ToDataStream(0, buffer, buffer.Length),
+                                loopStart,
+                                loopLength);
+
+                return;
+            }
+
+            throw new NotSupportedException("Unsupported sound format!");
+        }
+
+        private void PlatformLoadAudioStream(Stream stream, out TimeSpan duration)
+        {
+            SoundStream soundStream = null;
+            try
+            {
+                soundStream = new SoundStream(stream);
+            }
+            catch (InvalidOperationException ex)
+            {
+                throw new ArgumentException("Ensure that the specified stream contains valid PCM or IEEE Float wave data.", ex);
+            }
+
+            var dataStream = soundStream.ToDataStream();
+            int sampleCount = 0;
+            switch (soundStream.Format.Encoding)
+            {
+                case WaveFormatEncoding.Adpcm:
+                    {
+                        var samplesPerBlock = (soundStream.Format.BlockAlign / soundStream.Format.Channels - 7) * 2 + 2;
+                        sampleCount = ((int)dataStream.Length / soundStream.Format.BlockAlign) * samplesPerBlock;
+                    }
+                    break;
+                case WaveFormatEncoding.Pcm:
+                case WaveFormatEncoding.IeeeFloat:
+                    sampleCount = (int)(dataStream.Length / ((soundStream.Format.Channels * soundStream.Format.BitsPerSample) / 8));
+                    break;
+                default:
+                    throw new ArgumentException("Ensure that the specified stream contains valid PCM, MS-ADPCM or IEEE Float wave data.");
+            }
+
+            CreateBuffers(soundStream.Format, dataStream, 0, sampleCount);
+
+            duration = TimeSpan.FromSeconds((float)sampleCount / (float)soundStream.Format.SampleRate);
+        }
+
+        private void CreateBuffers(WaveFormat format, DataStream dataStream, int loopStart, int loopLength)
+        {
+            _format = format;
+            _dataStream = dataStream;
+
+            _buffer = new AudioBuffer
+            {
+                Stream = _dataStream,
+                AudioBytes = (int)_dataStream.Length,
+                Flags = BufferFlags.EndOfStream,
+                PlayBegin = loopStart,
+                PlayLength = loopLength,
+                Context = new IntPtr(42),
+            };
+
+            _loopedBuffer = new AudioBuffer
+            {
+                Stream = _dataStream,
+                AudioBytes = (int)_dataStream.Length,
+                Flags = BufferFlags.EndOfStream,
+                LoopBegin = loopStart,
+                LoopLength = loopLength,
+                LoopCount = AudioBuffer.LoopInfinite,
+                Context = new IntPtr(42),
+            };
+        }
+
+        private void PlatformSetupInstance(SoundEffectInstance inst)
+        {
+            // If the instance came from the pool then it could
+            // already have a valid voice assigned.
+            var voice = inst._voice;
+
+            if (voice != null)
+            {
+                // TODO: This really shouldn't be here.  Instead we should fix the 
+                // SoundEffectInstancePool to internally to look for a compatible
+                // instance or return a new instance without a voice.
+                //
+                // For now we do the same test that the pool should be doing here.
+             
+                if (!ReferenceEquals(inst._format, _format))
+                {
+                    if (inst._format.Encoding != _format.Encoding ||
+                        inst._format.Channels != _format.Channels ||
+                        inst._format.SampleRate != _format.SampleRate ||
+                        inst._format.BitsPerSample != _format.BitsPerSample)
+                    {
+                        voice.DestroyVoice();
+                        voice.Dispose();
+                        voice = null;
+                    }
+                }
+            }
+
+            if (voice == null && Device != null)
+            {
+                voice = new SourceVoice(Device, _format, VoiceFlags.UseFilter, XAudio2.MaximumFrequencyRatio);
+                inst._voice = voice;
+                inst.UpdateOutputMatrix(); // Ensure the output matrix is set for this new voice
+            }
+
+            inst._format = _format;
+        }
+
+        #endregion
+
+        internal static void PlatformSetReverbSettings(ReverbSettings reverbSettings)
+        {
+            // All parameters related to sampling rate or time are relative to a 48kHz 
+            // voice and must be scaled for use with other sampling rates.
+            var timeScale = 48000.0f / ReverbVoice.VoiceDetails.InputSampleRate;
+
+            var settings = new SharpDX.XAudio2.Fx.ReverbParameters
+            {
+                ReflectionsGain = reverbSettings.ReflectionsGainDb,
+                ReverbGain = reverbSettings.ReverbGainDb,
+                DecayTime = reverbSettings.DecayTimeSec,
+                ReflectionsDelay = (byte)(reverbSettings.ReflectionsDelayMs * timeScale),
+                ReverbDelay = (byte)(reverbSettings.ReverbDelayMs * timeScale),
+                RearDelay = (byte)(reverbSettings.RearDelayMs * timeScale),
+                RoomSize = reverbSettings.RoomSizeFeet,
+                Density = reverbSettings.DensityPct,
+                LowEQGain = (byte)reverbSettings.LowEqGain,
+                LowEQCutoff = (byte)reverbSettings.LowEqCutoff,
+                HighEQGain = (byte)reverbSettings.HighEqGain,
+                HighEQCutoff = (byte)reverbSettings.HighEqCutoff,
+                PositionLeft = (byte)reverbSettings.PositionLeft,
+                PositionRight = (byte)reverbSettings.PositionRight,
+                PositionMatrixLeft = (byte)reverbSettings.PositionLeftMatrix,
+                PositionMatrixRight = (byte)reverbSettings.PositionRightMatrix,
+                EarlyDiffusion = (byte)reverbSettings.EarlyDiffusion,
+                LateDiffusion = (byte)reverbSettings.LateDiffusion,
+                RoomFilterMain = reverbSettings.RoomFilterMainDb,
+                RoomFilterFreq = reverbSettings.RoomFilterFrequencyHz * timeScale,
+                RoomFilterHF = reverbSettings.RoomFilterHighFrequencyDb,
+                WetDryMix = reverbSettings.WetDryMixPct
+            };
+
+            ReverbVoice.SetEffectParameters(0, settings);
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (_dataStream != null)
+                    _dataStream.Dispose();
+            }
+            _dataStream = null;
+        }
+
+        internal static void PlatformShutdown()
+        {
+            if (_reverbVoice != null)
+            {
+                _reverbVoice.DestroyVoice();
+                _reverbVoice.Dispose();
+                _reverbVoice = null;
+            }
+
+            if (MasterVoice != null)
+            {
+                MasterVoice.Dispose();
+                MasterVoice = null;
+            }
+
+            if (Device != null)
+            {
+                Device.StopEngine();
+                Device.Dispose();
+                Device = null;
+            }
+
+            _device3DDirty = true;
+            _speakers = Speakers.Stereo;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/SoundEffect.cs b/MonoGame.Framework/Audio/SoundEffect.cs
new file mode 100644
index 00000000000..b5c3ebd1d36
--- /dev/null
+++ b/MonoGame.Framework/Audio/SoundEffect.cs
@@ -0,0 +1,517 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>Represents a loaded sound resource.</summary>
+    /// <remarks>
+    /// <para>A SoundEffect represents the buffer used to hold audio data and metadata. SoundEffectInstances are used to play from SoundEffects. Multiple SoundEffectInstance objects can be created and played from the same SoundEffect object.</para>
+    /// <para>The only limit on the number of loaded SoundEffects is restricted by available memory. When a SoundEffect is disposed, all SoundEffectInstances created from it will become invalid.</para>
+    /// <para>SoundEffect.Play() can be used for 'fire and forget' sounds. If advanced playback controls like volume or pitch is required, use SoundEffect.CreateInstance().</para>
+    /// </remarks>
+    public sealed partial class SoundEffect : IDisposable
+    {
+        #region Internal Audio Data
+
+        private string _name = string.Empty;
+        
+        private bool _isDisposed = false;
+        private readonly TimeSpan _duration;
+
+        #endregion
+
+        #region Internal Constructors
+
+        // Only used from SoundEffect.FromStream.
+        private SoundEffect(Stream stream)
+        {
+            Initialize();
+            if (_systemState != SoundSystemState.Initialized)
+                throw new NoAudioHardwareException("Audio has failed to initialize. Call SoundEffect.Initialize() before sound operation to get more specific errors.");
+
+            /*
+              The Stream object must point to the head of a valid PCM wave file. Also, this wave file must be in the RIFF bitstream format.
+              The audio format has the following restrictions:
+              Must be a PCM wave file
+              Can only be mono or stereo
+              Must be 8 or 16 bit
+              Sample rate must be between 8,000 Hz and 48,000 Hz
+            */
+
+            PlatformLoadAudioStream(stream, out _duration);
+        }
+
+        // Only used from SoundEffectReader.
+        internal SoundEffect(byte[] header, byte[] buffer, int bufferSize, int durationMs, int loopStart, int loopLength)
+        {
+            Initialize();
+            if (_systemState != SoundSystemState.Initialized)
+                throw new NoAudioHardwareException("Audio has failed to initialize. Call SoundEffect.Initialize() before sound operation to get more specific errors.");
+
+            _duration = TimeSpan.FromMilliseconds(durationMs);
+
+            // Peek at the format... handle regular PCM data.
+            var format = BitConverter.ToInt16(header, 0);
+            if (format == 1)
+            {
+                var channels = BitConverter.ToInt16(header, 2);
+                var sampleRate = BitConverter.ToInt32(header, 4);
+                var bitsPerSample = BitConverter.ToInt16(header, 14);
+                PlatformInitializePcm(buffer, 0, bufferSize, bitsPerSample, sampleRate, (AudioChannels)channels, loopStart, loopLength);
+                return;
+            }
+
+            // Everything else is platform specific.
+            PlatformInitializeFormat(header, buffer, bufferSize, loopStart, loopLength);
+        }
+
+        // Only used from XACT WaveBank.
+        internal SoundEffect(MiniFormatTag codec, byte[] buffer, int channels, int sampleRate, int blockAlignment, int loopStart, int loopLength)
+        {
+            Initialize();
+            if (_systemState != SoundSystemState.Initialized)
+                throw new NoAudioHardwareException("Audio has failed to initialize. Call SoundEffect.Initialize() before sound operation to get more specific errors.");
+
+            // Handle the common case... the rest is platform specific.
+            if (codec == MiniFormatTag.Pcm)
+            {
+                _duration = TimeSpan.FromSeconds((float)buffer.Length / (sampleRate * blockAlignment));
+                PlatformInitializePcm(buffer, 0, buffer.Length, 16, sampleRate, (AudioChannels)channels, loopStart, loopLength);
+                return;
+            }
+
+            PlatformInitializeXact(codec, buffer, channels, sampleRate, blockAlignment, loopStart, loopLength, out _duration);
+        }
+
+        #endregion
+
+        #region Audio System Initialization
+
+        internal enum SoundSystemState
+        {
+            NotInitialized,
+            Initialized,
+            FailedToInitialized
+        }
+
+        internal static SoundSystemState _systemState = SoundSystemState.NotInitialized;
+
+        /// <summary>
+        /// Initializes the sound system for SoundEffect support.
+        /// This method is automatically called when a SoundEffect is loaded, a DynamicSoundEffectInstance is created, or Microphone.All is queried.
+        /// You can however call this method manually (preferably in, or before the Game constructor) to catch any Exception that may occur during the sound system initialization (and act accordingly).
+        /// </summary>
+        public static void Initialize()
+        {
+            if (_systemState != SoundSystemState.NotInitialized)
+                return;
+
+            try
+            {
+                PlatformInitialize();
+                _systemState = SoundSystemState.Initialized;
+            }
+            catch (Exception)
+            {
+                _systemState = SoundSystemState.FailedToInitialized;
+                throw;
+            }
+        }
+
+        #endregion
+
+        #region Public Constructors
+
+        /// <summary>
+        /// Create a sound effect.
+        /// </summary>
+        /// <param name="buffer">The buffer with the sound data.</param>
+        /// <param name="sampleRate">The sound data sample rate in hertz.</param>
+        /// <param name="channels">The number of channels in the sound data.</param>
+        /// <remarks>This only supports uncompressed 16bit PCM wav data.</remarks>
+        public SoundEffect(byte[] buffer, int sampleRate, AudioChannels channels)
+             : this(buffer, 0, buffer != null ? buffer.Length : 0, sampleRate, channels, 0, 0)
+        {
+        }
+
+        /// <summary>
+        /// Create a sound effect.
+        /// </summary>
+        /// <param name="buffer">The buffer with the sound data.</param>
+        /// <param name="offset">The offset to the start of the sound data in bytes.</param>
+        /// <param name="count">The length of the sound data in bytes.</param>
+        /// <param name="sampleRate">The sound data sample rate in hertz.</param>
+        /// <param name="channels">The number of channels in the sound data.</param>
+        /// <param name="loopStart">The position where the sound should begin looping in samples.</param>
+        /// <param name="loopLength">The duration of the sound data loop in samples.</param>
+        /// <remarks>This only supports uncompressed 16bit PCM wav data.</remarks>
+        public SoundEffect(byte[] buffer, int offset, int count, int sampleRate, AudioChannels channels, int loopStart, int loopLength)
+        {
+            Initialize();
+            if (_systemState != SoundSystemState.Initialized)
+                throw new NoAudioHardwareException("Audio has failed to initialize. Call SoundEffect.Initialize() before sound operation to get more specific errors.");
+
+            if (sampleRate < 8000 || sampleRate > 48000)
+                throw new ArgumentOutOfRangeException("sampleRate");
+            if ((int)channels != 1 && (int)channels != 2)
+                throw new ArgumentOutOfRangeException("channels");
+
+            if (buffer == null || buffer.Length == 0)
+                throw new ArgumentException("Ensure that the buffer length is non-zero.", "buffer");
+
+            var blockAlign = (int)channels * 2;
+            if ((buffer.Length % blockAlign) != 0)
+                throw new ArgumentException("Ensure that the buffer meets the block alignment requirements for the number of channels.", "buffer");
+
+            if (count <= 0)
+                throw new ArgumentException("Ensure that the count is greater than zero.", "count");
+            if ((count % blockAlign) != 0)
+                throw new ArgumentException("Ensure that the count meets the block alignment requirements for the number of channels.", "count");
+
+            if (offset < 0)
+                throw new ArgumentException("The offset cannot be negative.", "offset");
+            if (((ulong)count + (ulong)offset) > (ulong)buffer.Length)
+                throw new ArgumentException("Ensure that the offset+count region lines within the buffer.", "offset");
+
+            var totalSamples = buffer.Length / blockAlign;
+
+            if (loopStart < 0)
+                throw new ArgumentException("The loopStart cannot be negative.", "loopStart");
+            if (loopStart > totalSamples)
+                throw new ArgumentException("The loopStart cannot be greater than the total number of samples.", "loopStart");
+
+            if (loopLength == 0)
+                loopLength = totalSamples - loopStart;
+
+            if (loopLength < 0)
+                throw new ArgumentException("The loopLength cannot be negative.", "loopLength");
+            if (((ulong)loopStart + (ulong)loopLength) > (ulong)totalSamples)
+                throw new ArgumentException("Ensure that the loopStart+loopLength region lies within the sample range.", "loopLength");
+
+            _duration = GetSampleDuration(count, sampleRate, channels);
+
+            PlatformInitializePcm(buffer, offset, count, 16, sampleRate, channels, loopStart, loopLength);
+        }
+
+        #endregion
+
+        #region Finalizer
+
+        /// <summary>
+        /// Releases unmanaged resources and performs other cleanup operations before the
+        /// <see cref="Microsoft.Xna.Framework.Audio.SoundEffect"/> is reclaimed by garbage collection.
+        /// </summary>
+        ~SoundEffect()
+        {
+            Dispose(false);
+        }
+
+        #endregion
+
+        #region Additional SoundEffect/SoundEffectInstance Creation Methods
+
+        /// <summary>
+        /// Creates a new SoundEffectInstance for this SoundEffect.
+        /// </summary>
+        /// <returns>A new SoundEffectInstance for this SoundEffect.</returns>
+        /// <remarks>Creating a SoundEffectInstance before calling SoundEffectInstance.Play() allows you to access advanced playback features, such as volume, pitch, and 3D positioning.</remarks>
+        public SoundEffectInstance CreateInstance()
+        {
+            var inst = new SoundEffectInstance();
+            PlatformSetupInstance(inst);
+
+            inst._isPooled = false;
+            inst._effect = this;
+
+            return inst;
+        }
+
+        /// <summary>
+        /// Creates a new SoundEffect object based on the specified data stream.
+        /// </summary>
+        /// <param name="stream">A stream containing the wave data.</param>
+        /// <returns>A new SoundEffect object.</returns>
+        /// <remarks>The stream must point to the head of a valid wave file in the RIFF bitstream format.  The formats supported are:
+        /// <list type="bullet">
+        /// <item>
+        /// <description>8-bit unsigned PCM</description>
+        /// <description>16-bit signed PCM</description>
+        /// <description>24-bit signed PCM</description>
+        /// <description>32-bit IEEE float PCM</description>
+        /// <description>MS-ADPCM 4-bit compressed</description>
+        /// <description>IMA/ADPCM (IMA4) 4-bit compressed</description>
+        /// </item>
+        /// </list>
+        /// </remarks>
+        public static SoundEffect FromStream(Stream stream)
+        {
+            if (stream == null)
+                throw new ArgumentNullException("stream");
+
+            return new SoundEffect(stream);
+        }
+
+        /// <summary>
+        /// Returns the duration for 16-bit PCM audio.
+        /// </summary>
+        /// <param name="sizeInBytes">The length of the audio data in bytes.</param>
+        /// <param name="sampleRate">Sample rate, in Hertz (Hz). Must be between 8000 Hz and 48000 Hz</param>
+        /// <param name="channels">Number of channels in the audio data.</param>
+        /// <returns>The duration of the audio data.</returns>
+        public static TimeSpan GetSampleDuration(int sizeInBytes, int sampleRate, AudioChannels channels)
+        {
+            if (sizeInBytes < 0)
+                throw new ArgumentException("Buffer size cannot be negative.", "sizeInBytes");
+            if (sampleRate < 8000 || sampleRate > 48000)
+                throw new ArgumentOutOfRangeException("sampleRate");
+
+            var numChannels = (int)channels;
+            if (numChannels != 1 && numChannels != 2)
+                throw new ArgumentOutOfRangeException("channels");
+
+            if (sizeInBytes == 0)
+                return TimeSpan.Zero;
+
+            // Reference
+            // http://tinyurl.com/hq9slfy
+
+            var dur = sizeInBytes / (sampleRate * numChannels * 16f / 8f);
+
+            var duration = TimeSpan.FromSeconds(dur);
+
+            return duration;
+        }
+
+        /// <summary>
+        /// Returns the data size in bytes for 16bit PCM audio.
+        /// </summary>
+        /// <param name="duration">The total duration of the audio data.</param>
+        /// <param name="sampleRate">Sample rate, in Hertz (Hz), of audio data. Must be between 8,000 and 48,000 Hz.</param>
+        /// <param name="channels">Number of channels in the audio data.</param>
+        /// <returns>The size in bytes of a single sample of audio data.</returns>
+        public static int GetSampleSizeInBytes(TimeSpan duration, int sampleRate, AudioChannels channels)
+        {
+            if (duration < TimeSpan.Zero || duration > TimeSpan.FromMilliseconds(0x7FFFFFF))
+                throw new ArgumentOutOfRangeException("duration");
+            if (sampleRate < 8000 || sampleRate > 48000)
+                throw new ArgumentOutOfRangeException("sampleRate");
+
+            var numChannels = (int)channels;
+            if (numChannels != 1 && numChannels != 2)
+                throw new ArgumentOutOfRangeException("channels");
+
+            // Reference
+            // http://tinyurl.com/hq9slfy
+
+            var sizeInBytes = duration.TotalSeconds * (sampleRate * numChannels * 16f / 8f);
+
+            return (int)sizeInBytes;
+        }
+
+        #endregion
+
+        #region Play
+
+        /// <summary>Gets an internal SoundEffectInstance and plays it.</summary>
+        /// <returns>True if a SoundEffectInstance was successfully played, false if not.</returns>
+        /// <remarks>
+        /// <para>Play returns false if more SoundEffectInstances are currently playing then the platform allows.</para>
+        /// <para>To loop a sound or apply 3D effects, call SoundEffect.CreateInstance() and SoundEffectInstance.Play() instead.</para>
+        /// <para>SoundEffectInstances used by SoundEffect.Play() are pooled internally.</para>
+        /// </remarks>
+        public bool Play()
+        {
+            var inst = GetPooledInstance(false);
+            if (inst == null)
+                return false;
+
+            inst.Play();
+
+            return true;
+        }
+
+        /// <summary>Gets an internal SoundEffectInstance and plays it with the specified volume, pitch, and panning.</summary>
+        /// <returns>True if a SoundEffectInstance was successfully created and played, false if not.</returns>
+        /// <param name="volume">Volume, ranging from 0.0 (silence) to 1.0 (full volume). Volume during playback is scaled by SoundEffect.MasterVolume.</param>
+        /// <param name="pitch">Pitch adjustment, ranging from -1.0 (down an octave) to 0.0 (no change) to 1.0 (up an octave).</param>
+        /// <param name="pan">Panning, ranging from -1.0 (left speaker) to 0.0 (centered), 1.0 (right speaker).</param>
+        /// <remarks>
+        /// <para>Play returns false if more SoundEffectInstances are currently playing then the platform allows.</para>
+        /// <para>To apply looping or simulate 3D audio, call SoundEffect.CreateInstance() and SoundEffectInstance.Play() instead.</para>
+        /// <para>SoundEffectInstances used by SoundEffect.Play() are pooled internally.</para>
+        /// </remarks>
+        public bool Play(float volume, float pitch, float pan)
+        {
+            var inst = GetPooledInstance(false);
+            if (inst == null)
+                return false;
+
+            inst.Volume = volume;
+            inst.Pitch = pitch;
+            inst.Pan = pan;
+
+            inst.Play();
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a sound effect instance from the pool or null if none are available.
+        /// </summary>
+        internal SoundEffectInstance GetPooledInstance(bool forXAct)
+        {
+            if (!SoundEffectInstancePool.SoundsAvailable)
+                return null;
+
+            var inst = SoundEffectInstancePool.GetInstance(forXAct);
+            inst._effect = this;
+            PlatformSetupInstance(inst);
+
+            return inst;
+        }
+
+        #endregion
+
+        #region Public Properties
+
+        /// <summary>Gets the duration of the SoundEffect.</summary>
+        public TimeSpan Duration { get { return _duration; } }
+
+        /// <summary>Gets or sets the asset name of the SoundEffect.</summary>
+        public string Name
+        {
+            get { return _name; }
+            set { _name = value; }
+        }
+
+        #endregion
+
+        #region Static Members
+
+        static float _masterVolume = 1.0f;
+        /// <summary>
+        /// Gets or sets the master volume scale applied to all SoundEffectInstances.
+        /// </summary>
+        /// <remarks>
+        /// <para>Each SoundEffectInstance has its own Volume property that is independent to SoundEffect.MasterVolume. During playback SoundEffectInstance.Volume is multiplied by SoundEffect.MasterVolume.</para>
+        /// <para>This property is used to adjust the volume on all current and newly created SoundEffectInstances. The volume of an individual SoundEffectInstance can be adjusted on its own.</para>
+        /// </remarks>
+        public static float MasterVolume 
+        { 
+            get { return _masterVolume; }
+            set
+            {
+                if (value < 0.0f || value > 1.0f)
+                    throw new ArgumentOutOfRangeException();
+
+                if (_masterVolume == value)
+                    return;
+                
+                _masterVolume = value;
+                SoundEffectInstancePool.UpdateMasterVolume();
+            }
+        }
+
+        static float _distanceScale = 1.0f;
+        /// <summary>
+        /// Gets or sets the scale of distance calculations.
+        /// </summary>
+        /// <remarks> 
+        /// <para>DistanceScale defaults to 1.0 and must be greater than 0.0.</para>
+        /// <para>Higher values reduce the rate of falloff between the sound and listener.</para>
+        /// </remarks>
+        public static float DistanceScale
+        {
+            get { return _distanceScale; }
+            set
+            {
+                if (value <= 0f)
+                    throw new ArgumentOutOfRangeException ("value of DistanceScale");
+
+                _distanceScale = value;
+            }
+        }
+
+        static float _dopplerScale = 1f;
+        /// <summary>
+        /// Gets or sets the scale of Doppler calculations applied to sounds.
+        /// </summary>
+        /// <remarks>
+        /// <para>DopplerScale defaults to 1.0 and must be greater or equal to 0.0</para>
+        /// <para>Affects the relative velocity of emitters and listeners.</para>
+        /// <para>Higher values more dramatically shift the pitch for the given relative velocity of the emitter and listener.</para>
+        /// </remarks>
+        public static float DopplerScale
+        {
+            get { return _dopplerScale; }
+            set
+            {
+                // As per documenation it does not look like the value can be less than 0
+                //   although the documentation does not say it throws an error we will anyway
+                //   just so it is like the DistanceScale
+                if (value < 0.0f)
+                    throw new ArgumentOutOfRangeException ("value of DopplerScale");
+
+                _dopplerScale = value;
+            }
+        }
+
+        static float speedOfSound = 343.5f;
+        /// <summary>Returns the speed of sound used when calculating the Doppler effect..</summary>
+        /// <remarks>
+        /// <para>Defaults to 343.5. Value is measured in meters per second.</para>
+        /// <para>Has no effect on distance attenuation.</para>
+        /// </remarks>
+        public static float SpeedOfSound
+        {
+            get { return speedOfSound; }
+            set
+            {
+                if (value <= 0.0f)
+                    throw new ArgumentOutOfRangeException();
+
+                speedOfSound = value;
+            }
+        }
+
+        #endregion
+
+        #region IDisposable Members
+
+        /// <summary>Indicates whether the object is disposed.</summary>
+        public bool IsDisposed { get { return _isDisposed; } }
+
+        /// <summary>Releases the resources held by this <see cref="Microsoft.Xna.Framework.Audio.SoundEffect"/>.</summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases the resources held by this <see cref="Microsoft.Xna.Framework.Audio.SoundEffect"/>.
+        /// </summary>
+        /// <param name="disposing">If set to <c>true</c>, Dispose was called explicitly.</param>
+        /// <remarks>If the disposing parameter is true, the Dispose method was called explicitly. This
+        /// means that managed objects referenced by this instance should be disposed or released as
+        /// required.  If the disposing parameter is false, Dispose was called by the finalizer and
+        /// no managed objects should be touched because we do not know if they are still valid or
+        /// not at that time.  Unmanaged resources should always be released.</remarks>
+        void Dispose(bool disposing)
+        {
+            if (!_isDisposed)
+            {
+                SoundEffectInstancePool.StopPooledInstances(this);
+                PlatformDispose(disposing);
+                _isDisposed = true;
+            }
+        }
+
+        #endregion
+
+    }
+}
diff --git a/MonoGame.Framework/Audio/SoundEffectInstance.OpenAL.cs b/MonoGame.Framework/Audio/SoundEffectInstance.OpenAL.cs
new file mode 100644
index 00000000000..929bc409b03
--- /dev/null
+++ b/MonoGame.Framework/Audio/SoundEffectInstance.OpenAL.cs
@@ -0,0 +1,356 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using MonoGame.OpenAL;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    public partial class SoundEffectInstance : IDisposable
+    {
+		internal SoundState SoundState = SoundState.Stopped;
+		private bool _looped = false;
+		private float _alVolume = 1f;
+
+		internal int SourceId;
+        private float reverb = 0f;
+        bool applyFilter = false;
+        EfxFilterType filterType;
+        float filterQ;
+        float frequency;
+        int pauseCount;
+        
+        internal OpenALSoundController controller;
+        
+        internal bool HasSourceId = false;
+
+#region Initialization
+
+        /// <summary>
+        /// Creates a standalone SoundEffectInstance from given wavedata.
+        /// </summary>
+        internal void PlatformInitialize(byte[] buffer, int sampleRate, int channels)
+        {
+            InitializeSound();
+        }
+
+        /// <summary>
+        /// Gets the OpenAL sound controller, constructs the sound buffer, and sets up the event delegates for
+        /// the reserved and recycled events.
+        /// </summary>
+        internal void InitializeSound()
+        {
+            controller = OpenALSoundController.Instance;
+        }
+
+#endregion // Initialization
+
+        /// <summary>
+        /// Converts the XNA [-1, 1] pitch range to OpenAL pitch (0, INF) or Android SoundPool playback rate [0.5, 2].
+        /// <param name="xnaPitch">The pitch of the sound in the Microsoft XNA range.</param>
+        /// </summary>
+        private static float XnaPitchToAlPitch(float xnaPitch)
+        {
+            return (float)Math.Pow(2, xnaPitch);
+        }
+
+        private void PlatformApply3D(AudioListener listener, AudioEmitter emitter)
+        {
+            if (!HasSourceId)
+                return;
+            // get AL's listener position
+            float x, y, z;
+            AL.GetListener(ALListener3f.Position, out x, out y, out z);
+            ALHelper.CheckError("Failed to get source position.");
+
+            // get the emitter offset from origin
+            Vector3 posOffset = emitter.Position - listener.Position;
+            // set up orientation matrix
+            Matrix orientation = Matrix.CreateWorld(Vector3.Zero, listener.Forward, listener.Up);
+            // set up our final position and velocity according to orientation of listener
+            Vector3 finalPos = new Vector3(x + posOffset.X, y + posOffset.Y, z + posOffset.Z);
+            finalPos = Vector3.Transform(finalPos, orientation);
+            Vector3 finalVel = emitter.Velocity;
+            finalVel = Vector3.Transform(finalVel, orientation);
+
+            // set the position based on relative positon
+            AL.Source(SourceId, ALSource3f.Position, finalPos.X, finalPos.Y, finalPos.Z);
+            ALHelper.CheckError("Failed to set source position.");
+            AL.Source(SourceId, ALSource3f.Velocity, finalVel.X, finalVel.Y, finalVel.Z);
+            ALHelper.CheckError("Failed to set source velocity.");
+
+            AL.Source(SourceId, ALSourcef.ReferenceDistance, SoundEffect.DistanceScale);
+            ALHelper.CheckError("Failed to set source distance scale.");
+            AL.DopplerFactor(SoundEffect.DopplerScale);
+            ALHelper.CheckError("Failed to set Doppler scale.");
+        }
+
+        private void PlatformPause()
+        {
+            if (!HasSourceId || SoundState != SoundState.Playing)
+                return;
+
+            if (pauseCount == 0)
+            {
+                AL.SourcePause(SourceId);
+                ALHelper.CheckError("Failed to pause source.");
+            }
+            ++pauseCount;
+            SoundState = SoundState.Paused;
+        }
+
+        private void PlatformPlay()
+        {
+            SourceId = 0;
+            HasSourceId = false;
+            SourceId = controller.ReserveSource();
+            HasSourceId = true;
+
+            int bufferId = _effect.SoundBuffer.OpenALDataBuffer;
+            AL.Source(SourceId, ALSourcei.Buffer, bufferId);
+            ALHelper.CheckError("Failed to bind buffer to source.");
+
+            // Send the position, gain, looping, pitch, and distance model to the OpenAL driver.
+            if (!HasSourceId)
+				return;
+
+            AL.Source(SourceId, ALSourcei.SourceRelative, 1);
+            ALHelper.CheckError("Failed set source relative.");
+            // Distance Model
+			AL.DistanceModel (ALDistanceModel.InverseDistanceClamped);
+            ALHelper.CheckError("Failed set source distance.");
+			// Pan
+			AL.Source (SourceId, ALSource3f.Position, _pan, 0f, 0f);
+            ALHelper.CheckError("Failed to set source pan.");
+            // Velocity
+			AL.Source (SourceId, ALSource3f.Velocity, 0f, 0f, 0f);
+            ALHelper.CheckError("Failed to set source pan.");
+			// Volume
+            AL.Source(SourceId, ALSourcef.Gain, _alVolume);
+            ALHelper.CheckError("Failed to set source volume.");
+			// Looping
+			AL.Source (SourceId, ALSourceb.Looping, IsLooped);
+            ALHelper.CheckError("Failed to set source loop state.");
+			// Pitch
+			AL.Source (SourceId, ALSourcef.Pitch, XnaPitchToAlPitch(_pitch));
+            ALHelper.CheckError("Failed to set source pitch.");
+
+            ApplyReverb ();
+            ApplyFilter ();
+
+            AL.SourcePlay(SourceId);
+            ALHelper.CheckError("Failed to play source.");
+
+            SoundState = SoundState.Playing;
+        }
+
+        private void PlatformResume()
+        {
+            if (!HasSourceId)
+            {
+                Play();
+                return;
+            }
+
+            if (SoundState == SoundState.Paused)
+            {
+                --pauseCount;
+                if (pauseCount == 0)
+                {
+                    AL.SourcePlay(SourceId);
+                    ALHelper.CheckError("Failed to play source.");
+                }
+            }
+            SoundState = SoundState.Playing;
+        }
+
+        private void PlatformStop(bool immediate)
+        {
+            if (HasSourceId)
+            {
+                AL.SourceStop(SourceId);
+                ALHelper.CheckError("Failed to stop source.");
+
+                // Reset the SendFilter to 0 if we are NOT using reverb since 
+                // sources are recycled
+                if (OpenALSoundController.Instance.SupportsEfx)
+                {
+                    OpenALSoundController.Efx.BindSourceToAuxiliarySlot(SourceId, 0, 0, 0);
+                    ALHelper.CheckError("Failed to unset reverb.");
+                    AL.Source(SourceId, ALSourcei.EfxDirectFilter, 0);
+                    ALHelper.CheckError("Failed to unset filter.");
+                }
+                AL.Source(SourceId, ALSourcei.Buffer, 0);
+                ALHelper.CheckError("Failed to free source from buffer.");
+
+                controller.FreeSource(this);
+            }
+            SoundState = SoundState.Stopped;
+        }
+
+        private void PlatformSetIsLooped(bool value)
+        {
+            _looped = value;
+
+            if (HasSourceId)
+            {
+                AL.Source(SourceId, ALSourceb.Looping, _looped);
+                ALHelper.CheckError("Failed to set source loop state.");
+            }
+        }
+
+        private bool PlatformGetIsLooped()
+        {
+            return _looped;
+        }
+
+        private void PlatformSetPan(float value)
+        {
+            if (HasSourceId)
+            {
+                AL.Source(SourceId, ALSource3f.Position, value, 0.0f, 0.1f);
+                ALHelper.CheckError("Failed to set source pan.");
+            }
+        }
+
+        private void PlatformSetPitch(float value)
+        {
+            if (HasSourceId)
+            {
+                AL.Source(SourceId, ALSourcef.Pitch, XnaPitchToAlPitch(value));
+                ALHelper.CheckError("Failed to set source pitch.");
+            }
+        }
+
+        private SoundState PlatformGetState()
+        {
+            if (!HasSourceId)
+                return SoundState.Stopped;
+            
+            var alState = AL.GetSourceState(SourceId);
+            ALHelper.CheckError("Failed to get source state.");
+
+            switch (alState)
+            {
+                case ALSourceState.Initial:
+                case ALSourceState.Stopped:
+                    SoundState = SoundState.Stopped;
+                    break;
+
+                case ALSourceState.Paused:
+                    SoundState = SoundState.Paused;
+                    break;
+
+                case ALSourceState.Playing:
+                    SoundState = SoundState.Playing;
+                    break;
+            }
+
+            return SoundState;
+        }
+
+        private void PlatformSetVolume(float value)
+        {
+            _alVolume = value;
+
+            if (HasSourceId)
+            {
+                AL.Source(SourceId, ALSourcef.Gain, _alVolume);
+                ALHelper.CheckError("Failed to set source volume.");
+            }
+        }
+
+        internal void PlatformSetReverbMix(float mix)
+        {
+            if (!OpenALSoundController.Efx.IsInitialized)
+                return;
+            reverb = mix;
+            if (State == SoundState.Playing)
+            {
+                ApplyReverb();
+                reverb = 0f;
+            }
+        }
+
+        void ApplyReverb()
+        {
+            if (reverb > 0f && SoundEffect.ReverbSlot != 0)
+            {
+                OpenALSoundController.Efx.BindSourceToAuxiliarySlot(SourceId, (int)SoundEffect.ReverbSlot, 0, 0);
+                ALHelper.CheckError("Failed to set reverb.");
+            }
+        }
+
+        void ApplyFilter()
+        {
+            if (applyFilter && controller.Filter > 0)
+            {
+                var freq = frequency / 20000f;
+                var lf = 1.0f - freq;
+                var efx = OpenALSoundController.Efx;
+                efx.Filter(controller.Filter, EfxFilteri.FilterType, (int)filterType);
+                ALHelper.CheckError("Failed to set filter.");
+                switch (filterType)
+                {
+                case EfxFilterType.Lowpass:
+                    efx.Filter(controller.Filter, EfxFilterf.LowpassGainHF, freq);
+                    ALHelper.CheckError("Failed to set LowpassGainHF.");
+                    break;
+                case EfxFilterType.Highpass:
+                    efx.Filter(controller.Filter, EfxFilterf.HighpassGainLF, freq);
+                    ALHelper.CheckError("Failed to set HighpassGainLF.");
+                    break;
+                case EfxFilterType.Bandpass:
+                    efx.Filter(controller.Filter, EfxFilterf.BandpassGainHF, freq);
+                    ALHelper.CheckError("Failed to set BandpassGainHF.");
+                    efx.Filter(controller.Filter, EfxFilterf.BandpassGainLF, lf);
+                    ALHelper.CheckError("Failed to set BandpassGainLF.");
+                    break;
+                }
+                AL.Source(SourceId, ALSourcei.EfxDirectFilter, controller.Filter);
+                ALHelper.CheckError("Failed to set DirectFilter.");
+            }
+        }
+
+        internal void PlatformSetFilter(FilterMode mode, float filterQ, float frequency)
+        {
+            if (!OpenALSoundController.Efx.IsInitialized)
+                return;
+
+            applyFilter = true;
+            switch (mode)
+            {
+            case FilterMode.BandPass:
+                filterType = EfxFilterType.Bandpass;
+                break;
+                case FilterMode.LowPass:
+                filterType = EfxFilterType.Lowpass;
+                break;
+                case FilterMode.HighPass:
+                filterType = EfxFilterType.Highpass;
+                break;
+            }
+            this.filterQ = filterQ;
+            this.frequency = frequency;
+            if (State == SoundState.Playing)
+            {
+                ApplyFilter();
+                applyFilter = false;
+            }
+        }
+
+        internal void PlatformClearFilter()
+        {
+            if (!OpenALSoundController.Efx.IsInitialized)
+                return;
+
+            applyFilter = false;
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            
+        }
+    }
+}
diff --git a/MonoGame.Framework/Audio/SoundEffectInstance.Web.cs b/MonoGame.Framework/Audio/SoundEffectInstance.Web.cs
new file mode 100644
index 00000000000..83981ee4331
--- /dev/null
+++ b/MonoGame.Framework/Audio/SoundEffectInstance.Web.cs
@@ -0,0 +1,78 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    public partial class SoundEffectInstance : IDisposable
+    {
+        internal void PlatformInitialize(byte[] buffer, int sampleRate, int channels)
+        {
+        }
+
+        private void PlatformApply3D(AudioListener listener, AudioEmitter emitter)
+        {
+        }
+
+        private void PlatformPause()
+        {
+        }
+
+        private void PlatformPlay()
+        {
+        }
+
+        private void PlatformResume()
+        {
+        }
+
+        private void PlatformStop(bool immediate)
+        {
+        }
+
+        private void PlatformSetIsLooped(bool value)
+        {
+        }
+
+        private bool PlatformGetIsLooped()
+        {
+            return false;
+        }
+
+        private void PlatformSetPan(float value)
+        {
+        }
+
+        private void PlatformSetPitch(float value)
+        {
+        }
+
+        private SoundState PlatformGetState()
+        {
+            return SoundState.Stopped;
+        }
+
+        private void PlatformSetVolume(float value)
+        {
+        }
+
+        internal void PlatformSetReverbMix(float mix)
+        {
+        }
+
+        internal void PlatformSetFilter(FilterMode mode, float filterQ, float frequency)
+        {
+        }
+
+        internal void PlatformClearFilter()
+        {
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+        }
+    }
+}
diff --git a/MonoGame.Framework/Audio/SoundEffectInstance.XAudio.cs b/MonoGame.Framework/Audio/SoundEffectInstance.XAudio.cs
new file mode 100644
index 00000000000..93eea625c98
--- /dev/null
+++ b/MonoGame.Framework/Audio/SoundEffectInstance.XAudio.cs
@@ -0,0 +1,388 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using SharpDX.XAudio2;
+using SharpDX.X3DAudio;
+using SharpDX.Multimedia;
+using SharpDX.Mathematics.Interop;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    public partial class SoundEffectInstance : IDisposable
+    {
+        private static float[] _defaultChannelAzimuths = new float[] { 0f, 0f };
+
+        internal SourceVoice _voice;
+        internal WaveFormat _format;
+
+        private SharpDX.XAudio2.Fx.Reverb _reverb;
+
+        private static readonly float[] _outputMatrix = new float[16];
+
+        private float _reverbMix;
+
+        private bool _paused;
+        private bool _loop;
+
+        private void PlatformInitialize(byte[] buffer, int sampleRate, int channels)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformApply3D(AudioListener listener, AudioEmitter emitter)
+        {
+            // If we have no voice then nothing to do.
+            if (_voice == null || SoundEffect.MasterVoice == null)
+                return;
+
+            // Convert from XNA Emitter to a SharpDX Emitter
+            var e = ToDXEmitter(emitter);
+            e.CurveDistanceScaler = SoundEffect.DistanceScale;
+            e.DopplerScaler = SoundEffect.DopplerScale;
+            e.ChannelCount = _effect._format.Channels;
+            
+            //stereo channel
+            if (e.ChannelCount > 1)
+            {
+                e.ChannelRadius = 0;
+                e.ChannelAzimuths = _defaultChannelAzimuths;
+             }
+
+            // Convert from XNA Listener to a SharpDX Listener
+            var l = ToDXListener(listener);
+
+            // Number of channels in the sound being played.
+            // Not actually sure if XNA supported 3D attenuation of sterio sounds, but X3DAudio does.
+            var srcChannelCount = _effect._format.Channels;
+
+            // Number of output channels.
+            var dstChannelCount = SoundEffect.MasterVoice.VoiceDetails.InputChannelCount;
+
+            // XNA supports distance attenuation and doppler.            
+            var dpsSettings = SoundEffect.Device3D.Calculate(l, e, CalculateFlags.Matrix | CalculateFlags.Doppler, srcChannelCount, dstChannelCount);
+
+            // Apply Volume settings (from distance attenuation) ...
+            _voice.SetOutputMatrix(SoundEffect.MasterVoice, srcChannelCount, dstChannelCount, dpsSettings.MatrixCoefficients, 0);
+
+            // Apply Pitch settings (from doppler) ...
+            _voice.SetFrequencyRatio(dpsSettings.DopplerFactor);
+        }
+
+        private Emitter _dxEmitter;
+        private Listener _dxListener;
+
+        private Emitter ToDXEmitter(AudioEmitter emitter)
+        {
+            // Pulling out Vector properties for efficiency.
+            var pos = emitter.Position;
+            var vel = emitter.Velocity;
+            var forward = emitter.Forward;
+            var up = emitter.Up;
+
+            // From MSDN:
+            //  X3DAudio uses a left-handed Cartesian coordinate system, 
+            //  with values on the x-axis increasing from left to right, on the y-axis from bottom to top, 
+            //  and on the z-axis from near to far. 
+            //  Azimuths are measured clockwise from a given reference direction. 
+            //
+            // From MSDN:
+            //  The XNA Framework uses a right-handed coordinate system, 
+            //  with the positive z-axis pointing toward the observer when the positive x-axis is pointing to the right, 
+            //  and the positive y-axis is pointing up. 
+            //
+            // Programmer Notes:         
+            //  According to this description the z-axis (forward vector) is inverted between these two coordinate systems.
+            //  Therefore, we need to negate the z component of any position/velocity values, and negate any forward vectors.
+
+            forward *= -1.0f;
+            pos.Z *= -1.0f;
+            vel.Z *= -1.0f;
+
+            if (_dxEmitter == null)
+                _dxEmitter = new Emitter();
+
+            _dxEmitter.Position = new RawVector3(pos.X, pos.Y, pos.Z);
+            _dxEmitter.Velocity = new RawVector3(vel.X, vel.Y, vel.Z);
+            _dxEmitter.OrientFront = new RawVector3(forward.X, forward.Y, forward.Z);
+            _dxEmitter.OrientTop = new RawVector3(up.X, up.Y, up.Z);
+            _dxEmitter.DopplerScaler = emitter.DopplerScale;
+            return _dxEmitter;
+        }
+
+        private Listener ToDXListener(AudioListener listener)
+        {
+            // Pulling out Vector properties for efficiency.
+            var pos = listener.Position;
+            var vel = listener.Velocity;
+            var forward = listener.Forward;
+            var up = listener.Up;
+
+            // From MSDN:
+            //  X3DAudio uses a left-handed Cartesian coordinate system, 
+            //  with values on the x-axis increasing from left to right, on the y-axis from bottom to top, 
+            //  and on the z-axis from near to far. 
+            //  Azimuths are measured clockwise from a given reference direction. 
+            //
+            // From MSDN:
+            //  The XNA Framework uses a right-handed coordinate system, 
+            //  with the positive z-axis pointing toward the observer when the positive x-axis is pointing to the right, 
+            //  and the positive y-axis is pointing up. 
+            //
+            // Programmer Notes:         
+            //  According to this description the z-axis (forward vector) is inverted between these two coordinate systems.
+            //  Therefore, we need to negate the z component of any position/velocity values, and negate any forward vectors.
+
+            forward *= -1.0f;
+            pos.Z *= -1.0f;
+            vel.Z *= -1.0f;
+
+            if (_dxListener == null)
+                _dxListener = new Listener();
+
+            _dxListener.Position = new RawVector3 { X = pos.X, Y = pos.Y, Z = pos.Z };
+            _dxListener.Velocity = new RawVector3 { X = vel.X, Y = vel.Y, Z = vel.Z };
+            _dxListener.OrientFront = new RawVector3 { X = forward.X, Y = forward.Y, Z = forward.Z };
+            _dxListener.OrientTop = new RawVector3 { X = up.X, Y = up.Y, Z = up.Z };
+            return _dxListener;
+        }
+
+        private void PlatformPause()
+        {
+            if (_voice != null && SoundEffect.MasterVoice != null)
+                _voice.Stop();
+            _paused = true;
+        }
+
+        private void PlatformPlay()
+        {
+            if (_voice != null && SoundEffect.MasterVoice != null)
+            {
+                // Choose the correct buffer depending on if we are looped.            
+                var buffer = _loop ? _effect._loopedBuffer : _effect._buffer;
+
+                if (_voice.State.BuffersQueued > 0)
+                {
+                    _voice.Stop();
+                    _voice.FlushSourceBuffers();
+                }
+
+                _voice.SubmitSourceBuffer(buffer, null);
+                _voice.Start();
+            }
+
+            _paused = false;
+        }
+
+        private void PlatformResume()
+        {
+            if (_voice != null && SoundEffect.MasterVoice != null)
+            {
+                // Restart the sound if (and only if) it stopped playing
+                if (!_loop)
+                {
+                    if (_voice.State.BuffersQueued == 0)
+                    {
+                        _voice.Stop();
+                        _voice.FlushSourceBuffers();
+                        _voice.SubmitSourceBuffer(_effect._buffer, null);
+                    }
+                }
+                _voice.Start();
+            }
+            _paused = false;
+        }
+
+        private void PlatformStop(bool immediate)
+        {
+            if (_voice != null && SoundEffect.MasterVoice != null)
+            {
+                if (immediate)
+                {
+                    _voice.Stop(0);
+                    _voice.FlushSourceBuffers();
+                }
+                else
+                    _voice.Stop((int)PlayFlags.Tails);
+            }
+
+            _paused = false;
+        }
+
+        private void PlatformSetIsLooped(bool value)
+        {
+            _loop = value;
+        }
+
+        private bool PlatformGetIsLooped()
+        {
+            return _loop;
+        }
+
+        private void PlatformSetPan(float value)
+        {
+            // According to XNA documentation:
+            // "Panning, ranging from -1.0f (full left) to 1.0f (full right). 0.0f is centered."
+            _pan = MathHelper.Clamp(value, -1.0f, 1.0f);
+
+            // If we have no voice then nothing more to do.
+            if (_voice == null || SoundEffect.MasterVoice == null)
+                return;
+
+            UpdateOutputMatrix();
+        }
+
+        internal void UpdateOutputMatrix()
+        {
+            var srcChannelCount = _voice.VoiceDetails.InputChannelCount;
+            var dstChannelCount = SoundEffect.MasterVoice.VoiceDetails.InputChannelCount;
+
+            // Set the pan on the correct channels based on the reverb mix.
+            if (!(_reverbMix > 0.0f))
+                _voice.SetOutputMatrix(srcChannelCount, dstChannelCount, CalculateOutputMatrix(_pan, 1.0f, srcChannelCount));
+            else
+            {
+                _voice.SetOutputMatrix(SoundEffect.ReverbVoice, srcChannelCount, dstChannelCount, CalculateOutputMatrix(_pan, _reverbMix, srcChannelCount));
+                _voice.SetOutputMatrix(SoundEffect.MasterVoice, srcChannelCount, dstChannelCount, CalculateOutputMatrix(_pan, 1.0f - Math.Min(_reverbMix, 1.0f), srcChannelCount));
+            }
+        }
+
+        internal static float[] CalculateOutputMatrix(float pan, float scale, int inputChannels)
+        {
+            // XNA only ever outputs to the front left/right speakers (channels 0 and 1)
+            // Assumes there are at least 2 speaker channels to output to
+
+            // Clear all the channels.
+            var outputMatrix = _outputMatrix;
+            Array.Clear(outputMatrix, 0, outputMatrix.Length);
+
+            if (inputChannels == 1) // Mono source
+            {
+                // Left/Right output levels:
+                //   Pan -1.0: L = 1.0, R = 0.0
+                //   Pan  0.0: L = 1.0, R = 1.0
+                //   Pan +1.0: L = 0.0, R = 1.0
+                outputMatrix[0] = (pan > 0f) ? ((1f - pan) * scale) : scale; // Front-left output
+                outputMatrix[1] = (pan < 0f) ? ((1f + pan) * scale) : scale; // Front-right output
+            }
+            else if (inputChannels == 2) // Stereo source
+            {
+                // Left/Right input (Li/Ri) mix for Left/Right outputs (Lo/Ro):
+                //   Pan -1.0: Lo = 0.5Li + 0.5Ri, Ro = 0.0Li + 0.0Ri
+                //   Pan  0.0: Lo = 1.0Li + 0.0Ri, Ro = 0.0Li + 1.0Ri
+                //   Pan +1.0: Lo = 0.0Li + 0.0Ri, Ro = 0.5Li + 0.5Ri
+                if (pan <= 0f)
+                {
+                    outputMatrix[0] = (1f + pan * 0.5f) * scale; // Front-left output, Left input
+                    outputMatrix[1] = (-pan * 0.5f) * scale; // Front-left output, Right input
+                    outputMatrix[2] = 0f; // Front-right output, Left input
+                    outputMatrix[3] = (1f + pan) * scale; // Front-right output, Right input
+                }
+                else
+                {
+                    outputMatrix[0] = (1f - pan) * scale; // Front-left output, Left input
+                    outputMatrix[1] = 0f; // Front-left output, Right input
+                    outputMatrix[2] = (pan * 0.5f) * scale; // Front-right output, Left input
+                    outputMatrix[3] = (1f - pan * 0.5f) * scale; // Front-right output, Right input
+                }
+            }
+
+            return outputMatrix;
+        }
+
+        private void PlatformSetPitch(float value)
+        {
+            _pitch = value;
+
+            if (_voice == null || SoundEffect.MasterVoice == null)
+                return;
+
+            // NOTE: This is copy of what XAudio2.SemitonesToFrequencyRatio() does
+            // which avoids the native call and is actually more accurate.
+             var pitch = (float)Math.Pow(2.0, value);
+             _voice.SetFrequencyRatio(pitch);
+        }
+
+        private SoundState PlatformGetState()
+        {
+            // If no voice or no buffers queued the sound is stopped.
+            if (_voice == null || SoundEffect.MasterVoice == null || _voice.State.BuffersQueued == 0)
+                return SoundState.Stopped;
+
+            // Because XAudio2 does not actually provide if a SourceVoice is Started / Stopped
+            // we have to save the "paused" state ourself.
+            if (_paused)
+                return SoundState.Paused;
+
+            return SoundState.Playing;
+        }
+
+        private void PlatformSetVolume(float value)
+        {
+            if (_voice != null && SoundEffect.MasterVoice != null)
+                _voice.SetVolume(value, XAudio2.CommitNow);
+        }
+
+        internal void PlatformSetReverbMix(float mix)
+        {
+            // At least for XACT we can't go over 2x the volume on the mix.
+            _reverbMix = MathHelper.Clamp(mix, 0, 2);
+
+            // If we have no voice then nothing more to do.
+            if (_voice == null || SoundEffect.MasterVoice == null)
+                return;
+
+            if (!(_reverbMix > 0.0f))
+                _voice.SetOutputVoices(new VoiceSendDescriptor(SoundEffect.MasterVoice));
+            else
+            {
+                _voice.SetOutputVoices( new VoiceSendDescriptor(SoundEffect.ReverbVoice), 
+                                        new VoiceSendDescriptor(SoundEffect.MasterVoice));
+            }
+
+            UpdateOutputMatrix();
+        }
+
+        internal void PlatformSetFilter(FilterMode mode, float filterQ, float frequency)
+        {
+            if (_voice == null || SoundEffect.MasterVoice == null)
+                return;
+
+            var filter = new FilterParameters 
+            {
+                Frequency = XAudio2.CutoffFrequencyToRadians(frequency, _voice.VoiceDetails.InputSampleRate), 
+                OneOverQ = 1.0f / filterQ, 
+                Type = (FilterType)mode 
+            };
+            _voice.SetFilterParameters(filter);
+        }
+
+        internal void PlatformClearFilter()
+        {
+            if (_voice == null || SoundEffect.MasterVoice == null)
+                return;
+
+            var filter = new FilterParameters { Frequency = 1.0f, OneOverQ = 1.0f, Type = FilterType.LowPassFilter };
+            _voice.SetFilterParameters(filter);            
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (_reverb != null)
+                    _reverb.Dispose();
+
+                if (_voice != null && SoundEffect.MasterVoice != null)
+                {
+                    _voice.DestroyVoice();
+                    _voice.Dispose();
+                }
+            }
+            _voice = null;
+            _effect = null;
+            _reverb = null;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Audio/SoundEffectInstance.cs b/MonoGame.Framework/Audio/SoundEffectInstance.cs
new file mode 100644
index 00000000000..14e3092fd84
--- /dev/null
+++ b/MonoGame.Framework/Audio/SoundEffectInstance.cs
@@ -0,0 +1,213 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>Represents a single instance of a playing, paused, or stopped sound.</summary>
+    /// <remarks>
+    /// <para>SoundEffectInstances are created through SoundEffect.CreateInstance() and used internally by SoundEffect.Play()</para>
+    /// </remarks>
+    public partial class SoundEffectInstance : IDisposable
+    {
+        private bool _isDisposed = false;
+        internal bool _isPooled = true;
+        internal bool _isXAct;
+        internal bool _isDynamic;
+        internal SoundEffect _effect;
+        private float _pan;
+        private float _volume;
+        private float _pitch;
+
+        /// <summary>Enables or Disables whether the SoundEffectInstance should repeat after playback.</summary>
+        /// <remarks>This value has no effect on an already playing sound.</remarks>
+        public virtual bool IsLooped
+        { 
+            get { return PlatformGetIsLooped(); }
+            set { PlatformSetIsLooped(value); }
+        }
+
+        /// <summary>Gets or sets the pan, or speaker balance..</summary>
+        /// <value>Pan value ranging from -1.0 (left speaker) to 0.0 (centered), 1.0 (right speaker). Values outside of this range will throw an exception.</value>
+        public float Pan
+        {
+            get { return _pan; } 
+            set
+            {
+                if (value < -1.0f || value > 1.0f)
+                    throw new ArgumentOutOfRangeException();
+
+                _pan = value;
+                PlatformSetPan(value);
+            }
+        }
+
+        /// <summary>Gets or sets the pitch adjustment.</summary>
+        /// <value>Pitch adjustment, ranging from -1.0 (down an octave) to 0.0 (no change) to 1.0 (up an octave). Values outside of this range will throw an Exception.</value>
+        public float Pitch
+        {
+            get { return _pitch; }
+            set
+            {
+                // XAct sounds effects don't have pitch limits
+                if (!_isXAct && (value < -1.0f || value > 1.0f))
+                    throw new ArgumentOutOfRangeException();
+
+                _pitch = value;
+                PlatformSetPitch(value);
+            }
+        }
+
+        /// <summary>Gets or sets the volume of the SoundEffectInstance.</summary>
+        /// <value>Volume, ranging from 0.0 (silence) to 1.0 (full volume). Volume during playback is scaled by SoundEffect.MasterVolume.</value>
+        /// <remarks>
+        /// This is the volume relative to SoundEffect.MasterVolume. Before playback, this Volume property is multiplied by SoundEffect.MasterVolume when determining the final mix volume.
+        /// </remarks>
+        public float Volume
+        {
+            get { return _volume; }
+            set
+            {
+                // XAct sound effects don't have volume limits.
+                if (!_isXAct && (value < 0.0f || value > 1.0f))
+                    throw new ArgumentOutOfRangeException();
+
+                _volume = value;
+
+                // XAct sound effects are not tied to the SoundEffect master volume.
+                if (_isXAct)
+                    PlatformSetVolume(value);
+                else
+                    PlatformSetVolume(value * SoundEffect.MasterVolume);
+            }
+        }
+
+        /// <summary>Gets the SoundEffectInstance's current playback state.</summary>
+        public virtual SoundState State { get { return PlatformGetState(); } }
+
+        /// <summary>Indicates whether the object is disposed.</summary>
+        public bool IsDisposed { get { return _isDisposed; } }
+
+        internal SoundEffectInstance()
+        {
+            _pan = 0.0f;
+            _volume = 1.0f;
+            _pitch = 0.0f;            
+        }
+
+        internal SoundEffectInstance(byte[] buffer, int sampleRate, int channels)
+            : this()
+        {
+            PlatformInitialize(buffer, sampleRate, channels);
+        }
+
+        /// <summary>
+        /// Releases unmanaged resources and performs other cleanup operations before the
+        /// <see cref="Microsoft.Xna.Framework.Audio.SoundEffectInstance"/> is reclaimed by garbage collection.
+        /// </summary>
+        ~SoundEffectInstance()
+        {
+            Dispose(false);
+        }
+
+        /// <summary>Applies 3D positioning to the SoundEffectInstance using a single listener.</summary>
+        /// <param name="listener">Data about the listener.</param>
+        /// <param name="emitter">Data about the source of emission.</param>
+        public void Apply3D(AudioListener listener, AudioEmitter emitter)
+        {
+            PlatformApply3D(listener, emitter);
+        }
+
+        /// <summary>Applies 3D positioning to the SoundEffectInstance using multiple listeners.</summary>
+        /// <param name="listeners">Data about each listener.</param>
+        /// <param name="emitter">Data about the source of emission.</param>
+        public void Apply3D(AudioListener[] listeners, AudioEmitter emitter)
+        {
+            foreach (var l in listeners)
+				PlatformApply3D(l, emitter);
+        }
+
+        /// <summary>Pauses playback of a SoundEffectInstance.</summary>
+        /// <remarks>Paused instances can be resumed with SoundEffectInstance.Play() or SoundEffectInstance.Resume().</remarks>
+        public virtual void Pause()
+        {
+            PlatformPause();
+        }
+
+        /// <summary>Plays or resumes a SoundEffectInstance.</summary>
+        /// <remarks>Throws an exception if more sounds are playing than the platform allows.</remarks>
+        public virtual void Play()
+        {
+            if (_isDisposed)
+                throw new ObjectDisposedException("SoundEffectInstance");
+
+            if (State == SoundState.Playing)
+                return;
+
+            // We don't need to check if we're at the instance play limit
+            // if we're resuming from a paused state.
+            if (State != SoundState.Paused)
+            {
+                if (!SoundEffectInstancePool.SoundsAvailable)
+                    throw new InstancePlayLimitException();
+
+                SoundEffectInstancePool.Remove(this);
+            }
+            
+            // For non-XAct sounds we need to be sure the latest
+            // master volume level is applied before playback.
+            if (!_isXAct)
+                PlatformSetVolume(_volume * SoundEffect.MasterVolume);
+
+            PlatformPlay();
+        }
+
+        /// <summary>Resumes playback for a SoundEffectInstance.</summary>
+        /// <remarks>Only has effect on a SoundEffectInstance in a paused state.</remarks>
+        public virtual void Resume()
+        {
+            PlatformResume();
+        }
+
+        /// <summary>Immediately stops playing a SoundEffectInstance.</summary>
+        public virtual void Stop()
+        {
+            PlatformStop(true);
+        }
+
+        /// <summary>Stops playing a SoundEffectInstance, either immediately or as authored.</summary>
+        /// <param name="immediate">Determined whether the sound stops immediately, or after playing its release phase and/or transitions.</param>
+        /// <remarks>Stopping a sound with the immediate argument set to false will allow it to play any release phases, such as fade, before coming to a stop.</remarks>
+        public virtual void Stop(bool immediate)
+        {
+            PlatformStop(immediate);
+        }
+
+        /// <summary>Releases the resources held by this <see cref="Microsoft.Xna.Framework.Audio.SoundEffectInstance"/>.</summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases the resources held by this <see cref="Microsoft.Xna.Framework.Audio.SoundEffectInstance"/>.
+        /// </summary>
+        /// <param name="disposing">If set to <c>true</c>, Dispose was called explicitly.</param>
+        /// <remarks>If the disposing parameter is true, the Dispose method was called explicitly. This
+        /// means that managed objects referenced by this instance should be disposed or released as
+        /// required.  If the disposing parameter is false, Dispose was called by the finalizer and
+        /// no managed objects should be touched because we do not know if they are still valid or
+        /// not at that time.  Unmanaged resources should always be released.</remarks>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_isDisposed)
+            {
+                PlatformDispose(disposing);
+                _isDisposed = true;
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Audio/SoundEffectInstancePool.cs b/MonoGame.Framework/Audio/SoundEffectInstancePool.cs
new file mode 100644
index 00000000000..a5e65dd4e12
--- /dev/null
+++ b/MonoGame.Framework/Audio/SoundEffectInstancePool.cs
@@ -0,0 +1,194 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    internal static class SoundEffectInstancePool
+    {
+        private static readonly List<SoundEffectInstance> _playingInstances;
+        private static readonly List<SoundEffectInstance> _pooledInstances;
+
+        private static readonly object _locker;
+
+        static SoundEffectInstancePool()
+        {
+            _locker = new object();
+
+            // Reduce garbage generation by allocating enough capacity for
+            // the maximum playing instances or at least some reasonable value.
+            var maxInstances = SoundEffect.MAX_PLAYING_INSTANCES < 1024 ? SoundEffect.MAX_PLAYING_INSTANCES : 1024;
+            _playingInstances = new List<SoundEffectInstance>(maxInstances);
+            _pooledInstances = new List<SoundEffectInstance>(maxInstances);
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the platform has capacity for more sounds to be played at this time.
+        /// </summary>
+        /// <value><c>true</c> if more sounds can be played; otherwise, <c>false</c>.</value>
+        internal static bool SoundsAvailable
+        {
+            get
+            {
+                lock(_locker)
+                	return _playingInstances.Count < SoundEffect.MAX_PLAYING_INSTANCES;
+            }
+        }
+
+        /// <summary>
+        /// Add the specified instance to the pool if it is a pooled instance and removes it from the
+        /// list of playing instances.
+        /// </summary>
+        /// <param name="inst">The SoundEffectInstance</param>
+        internal static void Add(SoundEffectInstance inst)
+        {
+            lock (_locker) {
+
+            if (inst._isPooled)
+            {
+                _pooledInstances.Add(inst);
+                inst._effect = null;
+            }
+
+            _playingInstances.Remove(inst);
+
+            } // lock(_locker)
+        }
+
+        /// <summary>
+        /// Adds the SoundEffectInstance to the list of playing instances.
+        /// </summary>
+        /// <param name="inst">The SoundEffectInstance to add to the playing list.</param>
+        internal static void Remove(SoundEffectInstance inst)
+        {
+            lock (_locker)
+                _playingInstances.Add(inst);
+        }
+
+        /// <summary>
+        /// Returns a pooled SoundEffectInstance if one is available, or allocates a new
+        /// SoundEffectInstance if the pool is empty.
+        /// </summary>
+        /// <returns>The SoundEffectInstance.</returns>
+        internal static SoundEffectInstance GetInstance(bool forXAct)
+        {
+            lock (_locker) {
+
+            SoundEffectInstance inst = null;
+            var count = _pooledInstances.Count;
+            if (count > 0)
+            {
+                // Grab the item at the end of the list so the remove doesn't copy all
+                // the list items down one slot.
+                inst = _pooledInstances[count - 1];
+                _pooledInstances.RemoveAt(count - 1);
+
+                // Reset used instance to the "default" state.
+                inst._isPooled = true;
+                inst._isXAct = forXAct;
+                inst.Volume = 1.0f;
+                inst.Pan = 0.0f;
+                inst.Pitch = 0.0f;
+                inst.IsLooped = false;
+                inst.PlatformSetReverbMix(0);
+                inst.PlatformClearFilter();
+            }
+            else
+            {
+                inst = new SoundEffectInstance();
+                inst._isPooled = true;
+                inst._isXAct = forXAct;
+            }
+
+            return inst;
+
+            } // lock (_locker)
+        }
+
+        /// <summary>
+        /// Iterates the list of playing instances, returning them to the pool if they
+        /// have stopped playing.
+        /// </summary>
+        internal static void Update()
+        {
+            lock (_locker) {
+
+            SoundEffectInstance inst = null;
+
+            // Cleanup instances which have finished playing.                    
+            for (var x = 0; x < _playingInstances.Count;)
+            {
+                inst = _playingInstances[x];
+
+                // Don't consume XACT instances... XACT will
+                // clear this flag when it is done with the wave.
+                if (inst._isXAct)
+                {
+                    x++;
+                    continue;
+                }
+
+                if (inst.IsDisposed || inst.State == SoundState.Stopped || (inst._effect == null && !inst._isDynamic))
+                {
+#if OPENAL
+                    if (!inst.IsDisposed)
+                        inst.Stop(true); // force stopping it to free its AL source
+#endif
+                    Add(inst);
+                    continue;
+                }
+
+                x++;
+            }
+
+            } // lock (_locker)
+        }
+
+        /// <summary>
+        /// Iterates the list of playing instances, stop them and return them to the pool if they are instances of the given SoundEffect.
+        /// </summary>
+        /// <param name="effect">The SoundEffect</param>
+        internal static void StopPooledInstances(SoundEffect effect)
+        {
+            lock (_locker) {
+
+            SoundEffectInstance inst = null;
+
+            for (var x = 0; x < _playingInstances.Count;)
+            {
+                inst = _playingInstances[x];
+                if (inst._effect == effect)
+                {
+                    inst.Stop(true); // stop immediatly
+                    Add(inst);
+                    continue;
+                }
+
+                x++;
+            }
+
+            } // lock (_locker)
+        }
+
+        internal static void UpdateMasterVolume()
+        {
+            lock (_locker) {
+
+            foreach (var inst in _playingInstances)
+            {
+                // XAct sounds are not controlled by the SoundEffect
+                // master volume, so we can skip them completely.
+                if (inst._isXAct)
+                    continue;
+
+                // Re-applying the volume to itself will update
+                // the sound with the current master volume.
+                inst.Volume = inst.Volume;
+            }
+        }
+
+        } // lock (_locker)
+    }
+}
diff --git a/MonoGame.Framework/Audio/SoundState.cs b/MonoGame.Framework/Audio/SoundState.cs
new file mode 100644
index 00000000000..8604a820f47
--- /dev/null
+++ b/MonoGame.Framework/Audio/SoundState.cs
@@ -0,0 +1,56 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+using System;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>Described the playback state of a SoundEffectInstance.</summary>
+    public enum SoundState
+    {
+        /// <summary>The SoundEffectInstance is currently playing.</summary>
+        Playing,
+        /// <summary>The SoundEffectInstance is currently paused.</summary>
+        Paused,
+        /// <summary>The SoundEffectInstance is currently stopped.</summary>
+        Stopped
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/Xact/AudioCategory.cs b/MonoGame.Framework/Audio/Xact/AudioCategory.cs
new file mode 100644
index 00000000000..f00deb4b15f
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/AudioCategory.cs
@@ -0,0 +1,210 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>
+    /// Provides functionality for manipulating multiple sounds at a time.
+    /// </summary>
+    public struct AudioCategory : IEquatable<AudioCategory>
+    {
+        readonly string _name;
+        readonly AudioEngine _engine;
+        readonly List<XactSound> _sounds;
+
+        // This is a bit gross, but we use an array here
+        // instead of a field since AudioCategory is a struct
+        // This allows us to save _volume when the user
+        // holds onto a reference of AudioCategory, or when a cue
+        // is created/loaded after the volume's already been set.
+        internal float[] _volume;
+
+        internal bool isBackgroundMusic;
+        internal bool isPublic;
+
+        internal bool instanceLimit;
+        internal int maxInstances;
+        internal MaxInstanceBehavior InstanceBehavior;
+
+        internal CrossfadeType fadeType;
+        internal float fadeIn;
+        internal float fadeOut;
+
+        
+        internal AudioCategory (AudioEngine audioengine, string name, BinaryReader reader)
+        {
+            Debug.Assert(audioengine != null);
+            Debug.Assert(!string.IsNullOrEmpty(name));
+
+            _sounds = new List<XactSound>();
+            _name = name;
+            _engine = audioengine;
+
+            maxInstances = reader.ReadByte ();
+            instanceLimit = maxInstances != 0xff;
+
+            fadeIn = (reader.ReadUInt16 () / 1000f);
+            fadeOut = (reader.ReadUInt16 () / 1000f);
+
+            byte instanceFlags = reader.ReadByte ();
+            fadeType = (CrossfadeType)(instanceFlags & 0x7);
+            InstanceBehavior = (MaxInstanceBehavior)(instanceFlags >> 3);
+
+            reader.ReadUInt16 (); //unkn
+
+            var volume = XactHelpers.ParseVolumeFromDecibels(reader.ReadByte());
+            _volume = new float[1] { volume };
+
+            byte visibilityFlags = reader.ReadByte ();
+            isBackgroundMusic = (visibilityFlags & 0x1) != 0;
+            isPublic = (visibilityFlags & 0x2) != 0;
+        }
+
+        internal void AddSound(XactSound sound)
+        {
+            _sounds.Add(sound);
+        }
+
+        internal int GetPlayingInstanceCount()
+        {
+            var sum = 0;
+            for (var i = 0; i < _sounds.Count; i++)
+            {
+                if (_sounds[i].Playing)
+                    sum++;
+            }
+            return sum;
+        }
+
+        internal XactSound GetOldestInstance()
+        {
+            for (var i = 0; i < _sounds.Count; i++)
+            {
+                if (_sounds[i].Playing)
+                    return _sounds[i];
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the category's friendly name.
+        /// </summary>
+        public string Name { get { return _name; } }
+
+        /// <summary>
+        /// Pauses all associated sounds.
+        /// </summary>
+        public void Pause ()
+        {
+            foreach (var sound in _sounds)
+                sound.Pause();
+        }
+
+        /// <summary>
+        /// Resumes all associated paused sounds.
+        /// </summary>
+        public void Resume ()
+        {
+            foreach (var sound in _sounds)
+                sound.Resume();
+        }
+
+        /// <summary>
+        /// Stops all associated sounds.
+        /// </summary>
+        public void Stop(AudioStopOptions options)
+        {
+            foreach (var sound in _sounds)
+                sound.Stop(options);
+        }
+
+        public void SetVolume(float volume)
+        {
+            if (volume < 0)
+                throw new ArgumentException("The volume must be positive.");
+
+            // Updating all the sounds in a category can be
+            // very expensive... so avoid it if we can.
+            if (_volume[0] == volume)
+                return;
+
+            _volume[0] = volume;
+
+            foreach (var sound in _sounds)
+                sound.UpdateCategoryVolume(volume);
+        }
+
+        /// <summary>
+        /// Determines whether two AudioCategory instances are equal.
+        /// </summary>
+        /// <param name="first">First AudioCategory instance to compare.</param>
+        /// <param name="second">Second AudioCategory instance to compare.</param>
+        /// <returns>true if the objects are equal or false if they aren't.</returns>
+        public static bool operator ==(AudioCategory first, AudioCategory second)
+        {
+            return first._engine == second._engine && first._name.Equals(second._name, StringComparison.Ordinal);
+        }
+
+        /// <summary>
+        /// Determines whether two AudioCategory instances are not equal.
+        /// </summary>
+        /// <param name="first">First AudioCategory instance to compare.</param>
+        /// <param name="second">Second AudioCategory instance to compare.</param>
+        /// <returns>true if the objects are not equal or false if they are.</returns>
+        public static bool operator !=(AudioCategory first, AudioCategory second)
+        {
+            return first._engine != second._engine || !first._name.Equals(second._name, StringComparison.Ordinal);
+        }
+
+        /// <summary>
+        /// Determines whether two AudioCategory instances are equal.
+        /// </summary>
+        /// <param name="other">AudioCategory to compare with this instance.</param>
+        /// <returns>true if the objects are equal or false if they aren't</returns>
+        public bool Equals(AudioCategory other)
+        {
+            return _engine == other._engine && _name.Equals(other._name, StringComparison.Ordinal);
+        }
+
+        /// <summary>
+        /// Determines whether two AudioCategory instances are equal.
+        /// </summary>
+        /// <param name="obj">Object to compare with this instance.</param>
+        /// <returns>true if the objects are equal or false if they aren't.</returns>
+        public override bool Equals(object obj)
+        {
+            if (obj is AudioCategory)
+            {
+                var other = (AudioCategory)obj;
+                return _engine == other._engine && _name.Equals(other._name, StringComparison.Ordinal);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Gets the hash code for this instance.
+        /// </summary>
+        /// <returns>Hash code for this object.</returns>
+        public override int GetHashCode()
+        {
+            return _name.GetHashCode() ^ _engine.GetHashCode();
+        }
+
+        /// <summary>
+        /// Returns the name of this AudioCategory
+        /// </summary>
+        /// <returns>Friendly name of the AudioCategory</returns>
+        public override string ToString()
+        {
+            return _name;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/Xact/AudioEngine.cs b/MonoGame.Framework/Audio/Xact/AudioEngine.cs
new file mode 100644
index 00000000000..fff74780136
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/AudioEngine.cs
@@ -0,0 +1,404 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>
+    /// Class used to create and manipulate code audio objects.
+    /// </summary> 
+    public class AudioEngine : IDisposable
+    {
+        private readonly AudioCategory[] _categories;
+        private readonly Dictionary<string, int> _categoryLookup = new Dictionary<string, int>();
+
+        private readonly RpcVariable[] _variables;
+        private readonly Dictionary<string, int> _variableLookup = new Dictionary<string, int>();
+
+        private readonly RpcVariable[] _cueVariables;
+
+        private readonly Stopwatch _stopwatch;
+        private TimeSpan _lastUpdateTime;
+
+        private readonly ReverbSettings _reverbSettings;
+        private readonly RpcCurve[] _reverbCurves;
+
+        internal List<Cue> ActiveCues = new List<Cue>();
+
+        internal AudioCategory[] Categories { get { return _categories; } }
+
+        internal Dictionary<string, WaveBank> Wavebanks = new Dictionary<string, WaveBank>();
+
+        internal readonly RpcCurve[] RpcCurves;
+
+        internal readonly object UpdateLock = new object();
+
+        internal RpcVariable[] CreateCueVariables()
+        {
+            var clone = new RpcVariable[_cueVariables.Length];
+            Array.Copy(_cueVariables, clone, _cueVariables.Length);
+            return clone;
+        }
+
+        /// <summary>
+        /// The current content version.
+        /// </summary>
+        public const int ContentVersion = 39;
+
+        /// <param name="settingsFile">Path to a XACT settings file.</param>
+        public AudioEngine(string settingsFile)
+            : this(settingsFile, TimeSpan.Zero, "")
+        {            
+        }
+
+        internal static Stream OpenStream(string filePath, bool useMemoryStream = false)
+        {
+            var stream = TitleContainer.OpenStream(filePath);
+
+            // Read the asset into memory in one go. This results in a ~50% reduction
+            // in load times on Android due to slow Android asset streams.
+#if ANDROID
+            useMemoryStream = true;
+#endif
+
+            if (useMemoryStream)
+            {
+                var memStream = new MemoryStream();
+                stream.CopyTo(memStream);
+                memStream.Seek(0, SeekOrigin.Begin);
+                stream.Dispose();
+                stream = memStream;
+            }
+
+            return stream;
+        }
+
+        /// <param name="settingsFile">Path to a XACT settings file.</param>
+        /// <param name="lookAheadTime">Determines how many milliseconds the engine will look ahead when determing when to transition to another sound.</param>
+        /// <param name="rendererId">A string that specifies the audio renderer to use.</param>
+        /// <remarks>For the best results, use a lookAheadTime of 250 milliseconds or greater.</remarks>
+        public AudioEngine(string settingsFile, TimeSpan lookAheadTime, string rendererId)
+        {
+            if (string.IsNullOrEmpty(settingsFile))
+                throw new ArgumentNullException("settingsFile");
+
+            // Read the xact settings file
+            // Credits to alisci01 for initial format documentation
+            using (var stream = OpenStream(settingsFile))
+            using (var reader = new BinaryReader(stream)) 
+            {
+                uint magic = reader.ReadUInt32 ();
+                if (magic != 0x46534758) //'XGFS'
+                    throw new ArgumentException ("XGS format not recognized");
+
+                reader.ReadUInt16 (); // toolVersion
+                uint formatVersion = reader.ReadUInt16();
+                if (formatVersion != 42)
+                    Debug.WriteLine("Warning: XGS format " + formatVersion + " not supported!");
+
+                reader.ReadUInt16 (); // crc
+                reader.ReadUInt32 (); // lastModifiedLow
+                reader.ReadUInt32 (); // lastModifiedHigh
+                reader.ReadByte (); //unkn, 0x03. Platform?
+
+                uint numCats = reader.ReadUInt16 ();
+                uint numVars = reader.ReadUInt16 ();
+
+                reader.ReadUInt16 (); //unkn, 0x16
+                reader.ReadUInt16 (); //unkn, 0x16
+
+                uint numRpc = reader.ReadUInt16 ();
+                uint numDspPresets = reader.ReadUInt16 (); 
+                uint numDspParams = reader.ReadUInt16 (); 
+
+                uint catsOffset = reader.ReadUInt32 ();
+                uint varsOffset = reader.ReadUInt32 ();
+
+                reader.ReadUInt32 (); //unknown, leads to a short with value of 1?
+                reader.ReadUInt32 (); // catNameIndexOffset
+                reader.ReadUInt32 (); //unknown, two shorts of values 2 and 3?
+                reader.ReadUInt32 (); // varNameIndexOffset
+
+                uint catNamesOffset = reader.ReadUInt32 ();
+                uint varNamesOffset = reader.ReadUInt32 ();
+                uint rpcOffset = reader.ReadUInt32 ();
+                reader.ReadUInt32(); // dspPresetsOffset
+                uint dspParamsOffset = reader.ReadUInt32 (); 
+
+                reader.BaseStream.Seek (catNamesOffset, SeekOrigin.Begin);
+                string[] categoryNames = ReadNullTerminatedStrings(numCats, reader);
+
+                _categories = new AudioCategory[numCats];
+                reader.BaseStream.Seek (catsOffset, SeekOrigin.Begin);
+                for (int i=0; i<numCats; i++) 
+                {
+                    _categories [i] = new AudioCategory (this, categoryNames [i], reader);
+                    _categoryLookup.Add (categoryNames [i], i);
+                }
+
+                reader.BaseStream.Seek (varNamesOffset, SeekOrigin.Begin);
+                string[] varNames = ReadNullTerminatedStrings(numVars, reader);
+
+                var variables = new List<RpcVariable>();
+                var cueVariables = new List<RpcVariable>();
+                var globalVariables = new List<RpcVariable>();
+                reader.BaseStream.Seek (varsOffset, SeekOrigin.Begin);
+                for (var i=0; i < numVars; i++)
+                {
+                    var v = new RpcVariable();
+                    v.Name = varNames[i];
+                    v.Flags = reader.ReadByte();						
+                    v.InitValue = reader.ReadSingle();
+                    v.MinValue = reader.ReadSingle();
+                    v.MaxValue = reader.ReadSingle();
+                    v.Value = v.InitValue;
+
+                    variables.Add(v);
+                    if (!v.IsGlobal)
+                        cueVariables.Add(v);
+                    else
+                    {
+                        globalVariables.Add(v);
+                        _variableLookup.Add(v.Name, globalVariables.Count - 1);                        
+                    }
+                }
+                _cueVariables = cueVariables.ToArray();
+                _variables = globalVariables.ToArray();
+
+                var reverbCurves = new List<RpcCurve>();
+                RpcCurves = new RpcCurve[numRpc];
+                if (numRpc > 0)
+                {
+                    reader.BaseStream.Seek(rpcOffset, SeekOrigin.Begin);
+                    for (var i=0; i < numRpc; i++)
+                    {
+                        var curve = new RpcCurve();
+                        curve.FileOffset = (uint)reader.BaseStream.Position;
+
+                        var variable = variables[ reader.ReadUInt16() ];
+                        if (variable.IsGlobal)
+                        {
+                            curve.IsGlobal = true;
+                            curve.Variable = globalVariables.FindIndex(e => e.Name == variable.Name);
+                        }
+                        else
+                        {
+                            curve.IsGlobal = false;
+                            curve.Variable = cueVariables.FindIndex(e => e.Name == variable.Name);
+                        }
+
+                        var pointCount = (int)reader.ReadByte();
+                        curve.Parameter = (RpcParameter)reader.ReadUInt16();
+
+                        curve.Points = new RpcPoint[pointCount];
+                        for (var j=0; j < pointCount; j++) 
+                        {
+                            curve.Points[j].Position = reader.ReadSingle();
+                            curve.Points[j].Value = reader.ReadSingle();
+                            curve.Points[j].Type = (RpcPointType)reader.ReadByte();
+                        }
+
+                        // If the parameter is greater than the max then this is a DSP
+                        // parameter which is for reverb.
+                        var dspParameter = curve.Parameter - RpcParameter.NumParameters;
+                        if (dspParameter >= 0 && variable.IsGlobal)
+                            reverbCurves.Add(curve);
+
+                        RpcCurves[i] = curve;
+                    }
+                }
+                _reverbCurves = reverbCurves.ToArray();
+
+                if (numDspPresets > 0)
+                {
+                    // Note:  It seemed like MS designed this to support multiple
+                    // DSP effects, but in practice XACT only has one... Microsoft Reverb.
+                    //
+                    // So because of this we know exactly how many presets and 
+                    // parameters we should have.
+                    if (numDspPresets != 1)
+                        throw new Exception("Unexpected number of DSP presets!");
+                    if (numDspParams != 22)
+                        throw new Exception("Unexpected number of DSP parameters!");
+
+                    reader.BaseStream.Seek(dspParamsOffset, SeekOrigin.Begin);
+                    _reverbSettings = new ReverbSettings(reader);
+                }
+            }
+
+            _stopwatch = new Stopwatch();
+            _stopwatch.Start();
+        }
+
+        internal int GetRpcIndex(uint fileOffset)
+        {
+            for (var i = 0; i < RpcCurves.Length; i++)
+            {
+                if (RpcCurves[i].FileOffset == fileOffset)
+                    return i;
+            }
+
+            return -1;
+        }
+
+        private static string[] ReadNullTerminatedStrings(uint count, BinaryReader reader)
+        {
+            var ret = new string[count];
+            
+            for (var i=0; i < count; i++) 
+            {
+                var s = new List<char>();
+                while (reader.PeekChar() != 0) 
+                    s.Add(reader.ReadChar()); 
+
+                reader.ReadChar();
+                ret[i] = new string(s.ToArray());
+            }
+
+            return ret;
+        }
+
+        /// <summary>
+        /// Performs periodic work required by the audio engine.
+        /// </summary>
+        /// <remarks>Must be called at least once per frame.</remarks>
+        public void Update()
+        {
+            var cur = _stopwatch.Elapsed;
+            var elapsed = cur - _lastUpdateTime;
+            _lastUpdateTime = cur;
+            var dt = (float)elapsed.TotalSeconds;
+
+            lock (UpdateLock)
+            {
+                for (var x = 0; x < ActiveCues.Count; )
+                {
+                    var cue = ActiveCues[x];
+
+                    cue.Update(dt);
+
+                    if (cue.IsStopped || cue.IsDisposed)
+                    {
+                        ActiveCues.Remove(cue);
+                        continue;
+                    }
+
+                    x++;
+                }
+            }
+
+            // The only global curves we can process seem to be 
+            // specifically for the reverb DSP effect.
+            if (_reverbSettings != null)
+            {
+                for (var i = 0; i < _reverbCurves.Length; i++)
+                {
+                    var curve = _reverbCurves[i];
+                    var result = curve.Evaluate(_variables[curve.Variable].Value);
+                    var parameter = curve.Parameter - RpcParameter.NumParameters;
+                    _reverbSettings[parameter] = result;
+                }
+
+                SoundEffect.PlatformSetReverbSettings(_reverbSettings);
+            }
+        }
+        
+        /// <summary>Returns an audio category by name.</summary>
+        /// <param name="name">Friendly name of the category to get.</param>
+        /// <returns>The AudioCategory with a matching name. Throws an exception if not found.</returns>
+        public AudioCategory GetCategory(string name)
+        {
+            if (string.IsNullOrEmpty(name))
+                throw new ArgumentNullException("name");
+
+            int i;
+            if (!_categoryLookup.TryGetValue(name, out i))
+                throw new InvalidOperationException("This resource could not be created.");
+
+            return _categories[i];
+        }
+
+        /// <summary>Gets the value of a global variable.</summary>
+        /// <param name="name">Friendly name of the variable.</param>
+        /// <returns>float value of the queried variable.</returns>
+        /// <remarks>A global variable has global scope. It can be accessed by all code within a project.</remarks>
+        public float GetGlobalVariable(string name)
+        {
+            if (string.IsNullOrEmpty(name))
+                throw new ArgumentNullException("name");
+
+            int i;
+            if (!_variableLookup.TryGetValue(name, out i) || !_variables[i].IsPublic)
+                throw new IndexOutOfRangeException("The specified variable index is invalid.");
+
+            lock (UpdateLock)
+                return _variables[i].Value;
+        }
+
+        internal float GetGlobalVariable(int index)
+        {
+            lock (UpdateLock)
+                return _variables[index].Value;
+        }
+
+        /// <summary>Sets the value of a global variable.</summary>
+        /// <param name="name">Friendly name of the variable.</param>
+        /// <param name="value">Value of the global variable.</param>
+        public void SetGlobalVariable(string name, float value)
+        {
+            if (string.IsNullOrEmpty(name))
+                throw new ArgumentNullException("name");
+
+            int i;
+            if (!_variableLookup.TryGetValue(name, out i) || !_variables[i].IsPublic)
+                throw new IndexOutOfRangeException("The specified variable index is invalid.");
+
+            lock (UpdateLock)
+                _variables[i].SetValue(value);
+        }
+
+        /// <summary>
+        /// This event is triggered when the AudioEngine is disposed.
+        /// </summary>
+        public event EventHandler<EventArgs> Disposing;
+
+        /// <summary>
+        /// Is true if the AudioEngine has been disposed.
+        /// </summary>
+        public bool IsDisposed { get; private set; }
+
+        /// <summary>
+        /// Disposes the AudioEngine.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        ~AudioEngine()
+        {
+            Dispose(false);
+        }
+
+        private void Dispose(bool disposing)
+        {
+            if (IsDisposed) 
+                return;
+
+            IsDisposed = true;
+
+            // TODO: Should we be forcing any active
+            // audio cues to stop here?
+
+            if (disposing)
+                EventHelpers.Raise(this, Disposing, EventArgs.Empty);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/Xact/AudioStopOptions.cs b/MonoGame.Framework/Audio/Xact/AudioStopOptions.cs
new file mode 100644
index 00000000000..704c7b51076
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/AudioStopOptions.cs
@@ -0,0 +1,18 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>Controls how Cue objects should cease playback when told to stop.</summary>
+	public enum AudioStopOptions
+	{
+        /// <summary>Stop normally, playing any pending release phases or transitions.</summary>
+		AsAuthored,
+        /// <summary>Immediately stops the cue, ignoring any pending release phases or transitions.</summary>
+		Immediate
+	}
+}
+
diff --git a/MonoGame.Framework/Audio/Xact/ClipEvent.cs b/MonoGame.Framework/Audio/Xact/ClipEvent.cs
new file mode 100644
index 00000000000..c2aace826aa
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/ClipEvent.cs
@@ -0,0 +1,36 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+	abstract class ClipEvent
+    {
+        protected XactClip _clip;
+
+	    protected ClipEvent(XactClip clip, float timeStamp, float randomOffset)
+        {
+            _clip = clip;
+            TimeStamp = timeStamp;
+            RandomOffset = randomOffset;
+        }
+
+	    public float RandomOffset { get; private set; }
+
+	    public float TimeStamp { get; private set; }
+
+	    public abstract void Play();
+	    public abstract void Stop();
+		public abstract void Pause();
+        public abstract void Resume();
+        public abstract void SetFade(float fadeInDuration, float fadeOutDuration);
+        public abstract void SetTrackVolume(float volume);
+        public abstract void SetTrackPan(float pan);
+        public abstract void SetState(float volume, float pitch, float reverbMix, float? filterFrequency, float? filterQFactor);
+	    public abstract bool Update(float dt);
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/Xact/CrossfadeType.cs b/MonoGame.Framework/Audio/Xact/CrossfadeType.cs
new file mode 100644
index 00000000000..c1594e39579
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/CrossfadeType.cs
@@ -0,0 +1,13 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    enum CrossfadeType 
+    {
+        Linear,
+        Logarithmic,
+        EqualPower,
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Audio/Xact/Cue.cs b/MonoGame.Framework/Audio/Xact/Cue.cs
new file mode 100644
index 00000000000..fe0e42dca64
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/Cue.cs
@@ -0,0 +1,378 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>Manages the playback of a sound or set of sounds.</summary>
+    /// <remarks>
+    /// <para>Cues are comprised of one or more sounds.</para>
+    /// <para>Cues also define specific properties such as pitch or volume.</para>
+    /// <para>Cues are referenced through SoundBank objects.</para>
+    /// </remarks>
+    public class Cue : IDisposable
+    {
+        private readonly AudioEngine _engine;
+        private readonly string _name;
+        private readonly XactSound[] _sounds;
+        private readonly float[] _probs;
+
+        private readonly RpcVariable[] _variables;
+
+        private XactSound _curSound;
+
+        private bool _applied3D;
+        private bool _played;
+
+        /// <summary>Indicates whether or not the cue is currently paused.</summary>
+        /// <remarks>IsPlaying and IsPaused both return true if a cue is paused while playing.</remarks>
+        public bool IsPaused
+        {
+            get 
+            {
+                if (_curSound != null)
+                    return _curSound.IsPaused;
+
+                return false;
+            }
+        }
+
+        /// <summary>Indicates whether or not the cue is currently playing.</summary>
+        /// <remarks>IsPlaying and IsPaused both return true if a cue is paused while playing.</remarks>
+        public bool IsPlaying
+        {
+            get 
+            {
+                if (_curSound != null)
+                    return _curSound.Playing;
+
+                return false;
+            }
+        }
+
+        /// <summary>Indicates whether or not the cue is currently stopped.</summary>
+        public bool IsStopped
+        {
+            get 
+            {
+                if (_curSound != null)
+                    return _curSound.Stopped;
+
+                return !IsDisposed && !IsPrepared;
+            }
+        }
+
+        public bool IsStopping
+        {
+            get
+            {
+                // TODO: Implement me!
+                return false;
+            }
+        }
+
+        public bool IsPreparing 
+        {
+            get { return false; }
+        }
+
+        public bool IsPrepared { get; internal set; }
+
+        public bool IsCreated { get; internal set; }
+
+        /// <summary>Gets the friendly name of the cue.</summary>
+        /// <remarks>The friendly name is a value set from the designer.</remarks>
+        public string Name
+        {
+            get { return _name; }
+        }
+        
+        internal Cue(AudioEngine engine, string cuename, XactSound sound)
+        {
+            _engine = engine;
+            _name = cuename;
+            _sounds = new XactSound[1];
+            _sounds[0] = sound;
+            _probs = new float[1];
+            _probs[0] = 1.0f;
+            _variables = engine.CreateCueVariables();
+        }
+        
+        internal Cue(AudioEngine engine, string cuename, XactSound[] sounds, float[] probs)
+        {
+            _engine = engine;
+            _name = cuename;
+            _sounds = sounds;
+            _probs = probs;
+            _variables = engine.CreateCueVariables();
+        }
+
+        internal void Prepare()
+        {
+            IsDisposed = false;
+            IsCreated = false;
+            IsPrepared = true;
+            _curSound = null;
+        }
+
+        /// <summary>Pauses playback.</summary>
+        public void Pause()
+        {
+            lock (_engine.UpdateLock)
+            {
+                if (_curSound != null)
+                    _curSound.Pause();
+            }
+        }
+
+        /// <summary>Requests playback of a prepared or preparing Cue.</summary>
+        /// <remarks>Calling Play when the Cue already is playing can result in an InvalidOperationException.</remarks>
+        public void Play()
+        {
+            lock (_engine.UpdateLock)
+            {
+                if (!_engine.ActiveCues.Contains(this))
+                    _engine.ActiveCues.Add(this);
+
+                //TODO: Probabilities
+                var index = XactHelpers.Random.Next(_sounds.Length);
+                _curSound = _sounds[index];
+
+                var volume = UpdateRpcCurves();
+
+                _curSound.Play(volume, _engine);
+            }
+
+            _played = true;
+            IsPrepared = false;
+        }
+
+        /// <summary>Resumes playback of a paused Cue.</summary>
+        public void Resume()
+        {
+            lock (_engine.UpdateLock)
+            {
+                if (_curSound != null)
+                    _curSound.Resume();
+            }
+        }
+
+        /// <summary>Stops playback of a Cue.</summary>
+        /// <param name="options">Specifies if the sound should play any pending release phases or transitions before stopping.</param>
+        public void Stop(AudioStopOptions options)
+        {
+            lock (_engine.UpdateLock)
+            {
+                _engine.ActiveCues.Remove(this);
+
+                if (_curSound != null)
+                    _curSound.Stop(options);
+            }
+
+            IsPrepared = false;
+        }
+
+        private int FindVariable(string name)
+        {
+            // Do a simple linear search... which is fast
+            // for as little variables as most cues have.
+            for (var i = 0; i < _variables.Length; i++)
+            {
+                if (_variables[i].Name == name)
+                    return i;
+            }
+
+            return -1;
+        }
+
+        /// <summary>
+        /// Sets the value of a cue-instance variable based on its friendly name.
+        /// </summary>
+        /// <param name="name">Friendly name of the variable to set.</param>
+        /// <param name="value">Value to assign to the variable.</param>
+        /// <remarks>The friendly name is a value set from the designer.</remarks>
+        public void SetVariable(string name, float value)
+        {
+            if (string.IsNullOrEmpty(name))
+                throw new ArgumentNullException("name");
+
+            var i = FindVariable(name);
+            if (i == -1 || !_variables[i].IsPublic)
+                throw new IndexOutOfRangeException("The specified variable index is invalid.");
+
+            _variables[i].SetValue(value);
+        }
+
+        /// <summary>Gets a cue-instance variable value based on its friendly name.</summary>
+        /// <param name="name">Friendly name of the variable.</param>
+        /// <returns>Value of the variable.</returns>
+        /// <remarks>
+        /// <para>Cue-instance variables are useful when multiple instantiations of a single cue (and its associated sounds) are required (for example, a "car" cue where there may be more than one car at any given time). While a global variable allows multiple audio elements to be controlled in unison, a cue instance variable grants discrete control of each instance of a cue, even for each copy of the same cue.</para>
+        /// <para>The friendly name is a value set from the designer.</para>
+        /// </remarks>
+        public float GetVariable(string name)
+        {
+            if (string.IsNullOrEmpty(name))
+                throw new ArgumentNullException("name");
+
+            var i = FindVariable(name);
+            if (i == -1 || !_variables[i].IsPublic)
+                throw new IndexOutOfRangeException("The specified variable index is invalid.");
+
+            return _variables[i].Value;
+        }
+
+        /// <summary>Updates the simulated 3D Audio settings calculated between an AudioEmitter and AudioListener.</summary>
+        /// <param name="listener">The listener to calculate.</param>
+        /// <param name="emitter">The emitter to calculate.</param>
+        /// <remarks>
+        /// <para>This must be called before Play().</para>
+        /// <para>Calling this method automatically converts the sound to monoaural and sets the speaker mix for any sound played by this cue to a value calculated with the listener's and emitter's positions. Any stereo information in the sound will be discarded.</para>
+        /// </remarks>
+        public void Apply3D(AudioListener listener, AudioEmitter emitter) 
+        {
+            if (listener == null)
+                throw new ArgumentNullException("listener");
+            if (emitter == null)
+                throw new ArgumentNullException("emitter");
+
+            if (_played && !_applied3D)
+                throw new InvalidOperationException("You must call Apply3D on a Cue before calling Play to be able to call Apply3D after calling Play.");
+
+            var direction = listener.Position - emitter.Position;
+
+            lock (_engine.UpdateLock)
+            {
+                // Set the distance for falloff.
+                var distance = direction.Length();
+                var i = FindVariable("Distance");
+                _variables[i].SetValue(distance);
+
+                // Calculate the orientation.
+                if (distance > 0.0f)
+                    direction /= distance;
+                var right = Vector3.Cross(listener.Up, listener.Forward);
+                var slope = Vector3.Dot(direction, listener.Forward);
+                var angle = MathHelper.ToDegrees((float)Math.Acos(slope));
+                var j = FindVariable("OrientationAngle");
+                _variables[j].SetValue(angle);
+                if (_curSound != null)
+                    _curSound.SetCuePan(Vector3.Dot(direction, right));
+
+                // Calculate doppler effect.
+                var relativeVelocity = emitter.Velocity - listener.Velocity;
+                relativeVelocity *= emitter.DopplerScale;
+            }
+
+            _applied3D = true;
+        }
+
+        internal void Update(float dt)
+        {
+            if (_curSound == null)
+                return;
+
+            _curSound.Update(dt);
+
+            UpdateRpcCurves();
+        }
+
+        private float UpdateRpcCurves()
+        {
+            var volume = 1.0f;
+
+            // Evaluate the runtime parameter controls.
+            var rpcCurves = _curSound.RpcCurves;
+            if (rpcCurves.Length > 0)
+            {
+                var pitch = 0.0f;
+                var reverbMix = 1.0f;
+                float? filterFrequency = null;
+                float? filterQFactor = null;
+
+                for (var i = 0; i < rpcCurves.Length; i++)
+                {
+                    var rpcCurve = _engine.RpcCurves[rpcCurves[i]];
+
+                    // Some curves are driven by global variables and others by cue instance variables.
+                    float value;
+                    if (rpcCurve.IsGlobal)
+                        value = rpcCurve.Evaluate(_engine.GetGlobalVariable(rpcCurve.Variable));
+                    else
+                        value = rpcCurve.Evaluate(_variables[rpcCurve.Variable].Value);
+
+                    // Process the final curve value based on the parameter type it is.
+                    switch (rpcCurve.Parameter)
+                    {
+                        case RpcParameter.Volume:
+                            volume *= XactHelpers.ParseVolumeFromDecibels(value / 100.0f);
+                            break;
+
+                        case RpcParameter.Pitch:
+                            pitch += value / 1000.0f;
+                            break;
+
+                        case RpcParameter.ReverbSend:
+                            reverbMix *= XactHelpers.ParseVolumeFromDecibels(value / 100.0f);
+                            break;
+
+                        case RpcParameter.FilterFrequency:
+                            filterFrequency = value;
+                            break;
+
+                        case RpcParameter.FilterQFactor:
+                            filterQFactor = value;
+                            break;
+
+                        default:
+                            throw new ArgumentOutOfRangeException("rpcCurve.Parameter");
+                    }
+                }
+
+                pitch = MathHelper.Clamp(pitch, -1.0f, 1.0f);
+                if (volume < 0.0f)
+                    volume = 0.0f;
+
+                _curSound.UpdateState(_engine, volume, pitch, reverbMix, filterFrequency, filterQFactor);
+            }
+
+            return volume;
+        }
+        
+        /// <summary>
+        /// This event is triggered when the Cue is disposed.
+        /// </summary>
+        public event EventHandler<EventArgs> Disposing;
+
+        /// <summary>
+        /// Is true if the Cue has been disposed.
+        /// </summary>
+        public bool IsDisposed { get; internal set; }
+
+        /// <summary>
+        /// Disposes the Cue.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        private void Dispose(bool disposing)
+        {
+            if (IsDisposed)
+                return;
+
+            IsDisposed = true;
+
+            if (disposing)
+            {
+                IsCreated = false;
+                IsPrepared = false;
+                EventHelpers.Raise(this, Disposing, EventArgs.Empty);
+            }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/Xact/DspParameter.cs b/MonoGame.Framework/Audio/Xact/DspParameter.cs
new file mode 100644
index 00000000000..4ecf9cefe0a
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/DspParameter.cs
@@ -0,0 +1,47 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    struct DspParameter
+    {
+        public float Value;
+        public readonly float MinValue;
+        public readonly float MaxValue;
+
+        public DspParameter(BinaryReader reader)
+        {
+            // This is 1 if the type is byte sized and 0 for 
+            // floats... not sure if we should use this info.
+            reader.ReadByte();
+            
+            // The value and the min/max range for limiting the 
+            // results from the RPC curve when animated.
+            Value = reader.ReadSingle();
+            MinValue = reader.ReadSingle();
+            MaxValue = reader.ReadSingle();
+
+            // Looks to always be zero...  maybe some padding
+            // for future expansion that never occured?
+            reader.ReadUInt16();
+        }
+
+        public void SetValue(float value)
+        {
+            if (value < MinValue)
+                Value = MinValue;
+            else if (value > MaxValue)
+                Value = MaxValue;
+            else
+                Value = value;
+        }
+
+        public override string ToString()
+        {
+            return "Value:" + Value + " MinValue:" + MinValue + " MaxValue:" + MaxValue;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Audio/Xact/FilterMode.cs b/MonoGame.Framework/Audio/Xact/FilterMode.cs
new file mode 100644
index 00000000000..e2970c2c8b5
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/FilterMode.cs
@@ -0,0 +1,13 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    enum FilterMode
+    {
+        LowPass = 0,
+        BandPass = 1,
+        HighPass = 2,
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Audio/Xact/MaxInstanceBehavior.cs b/MonoGame.Framework/Audio/Xact/MaxInstanceBehavior.cs
new file mode 100644
index 00000000000..6bc9e61a1c4
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/MaxInstanceBehavior.cs
@@ -0,0 +1,15 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    enum MaxInstanceBehavior 
+    {
+        FailToPlay,
+        Queue,
+        ReplaceOldest,
+        ReplaceQuietest,
+        ReplaceLowestPriority,
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Audio/Xact/MiniFormatTag.cs b/MonoGame.Framework/Audio/Xact/MiniFormatTag.cs
new file mode 100644
index 00000000000..ee94888329a
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/MiniFormatTag.cs
@@ -0,0 +1,17 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    enum MiniFormatTag 
+    {
+        Pcm = 0x0,
+        Xma = 0x1,
+        Adpcm = 0x2,
+        Wma = 0x3,
+
+        // We allow XMA to be reused for a platform specific format.
+        PlatformSpecific = Xma,
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Audio/Xact/PlayWaveEvent.cs b/MonoGame.Framework/Audio/Xact/PlayWaveEvent.cs
new file mode 100644
index 00000000000..1192057a9e4
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/PlayWaveEvent.cs
@@ -0,0 +1,303 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    enum VariationType
+    {
+        Ordered,
+        OrderedFromRandom,
+        Random,
+        RandomNoImmediateRepeats,
+        Shuffle
+    };
+
+    class PlayWaveEvent : ClipEvent
+    {
+        private readonly SoundBank _soundBank;
+
+        private readonly VariationType _variation;
+
+        private readonly int _loopCount;
+
+        private readonly bool _newWaveOnLoop;
+
+        private readonly int[] _tracks;
+        private readonly int[] _waveBanks;
+        
+        private readonly byte[] _weights;
+        private readonly int _totalWeights;
+
+        private float _trackVolume;
+        private float _trackPitch;
+        private float _trackFilterFrequency;
+        private float _trackFilterQFactor;
+
+        private float _clipVolume;
+        private float _clipPitch;
+        private float _clipReverbMix;
+
+        private readonly Vector4? _filterVar;
+        private readonly Vector2? _volumeVar;
+        private readonly Vector2? _pitchVar;
+
+        private int _wavIndex;
+        private int _loopIndex;
+
+        private SoundEffectInstance _wav;
+        private bool _streaming;
+
+        public PlayWaveEvent(   XactClip clip, float timeStamp, float randomOffset, SoundBank soundBank,
+                                int[] waveBanks, int[] tracks, byte[] weights, int totalWeights,
+                                VariationType variation, Vector2? volumeVar, Vector2? pitchVar, Vector4? filterVar,
+                                int loopCount, bool newWaveOnLoop)
+            : base(clip, timeStamp, randomOffset)
+        {
+            _soundBank = soundBank;
+            _waveBanks = waveBanks;
+            _tracks = tracks;
+            _weights = weights;
+            _totalWeights = totalWeights;
+            _volumeVar = volumeVar;
+            _pitchVar = pitchVar;
+            _filterVar = filterVar;
+            _wavIndex = -1;
+            _loopIndex = 0;
+
+            _trackVolume = 1.0f;
+            _trackPitch = 0;
+            _trackFilterFrequency = 0;
+            _trackFilterQFactor = 0;
+
+            _clipVolume = 1.0f;
+            _clipPitch = 0;
+            _clipReverbMix = 0;
+
+            _variation = variation;
+            _loopCount = loopCount;
+            _newWaveOnLoop = newWaveOnLoop;
+        }
+
+        public override void Play() 
+        {
+            if (_wav != null)
+            {
+                if (_wav.State != SoundState.Stopped)
+                    _wav.Stop();
+                if (_streaming)
+                    _wav.Dispose();
+				else					
+					_wav._isXAct = false;					
+                _wav = null;
+            }
+
+            Play(true);
+        }
+
+        private void Play(bool pickNewWav)
+        {
+            var trackCount = _tracks.Length;
+
+            // Do we need to pick a new wav to play first?
+            if (pickNewWav)
+            {
+                switch (_variation)
+                {
+                    case VariationType.Ordered:
+                        _wavIndex = (_wavIndex + 1) % trackCount;
+                        break;
+
+                    case VariationType.OrderedFromRandom:
+                        _wavIndex = (_wavIndex + 1) % trackCount;
+                        break;
+
+                    case VariationType.Random:
+                        if (_weights == null || trackCount == 1)
+                            _wavIndex = XactHelpers.Random.Next() % trackCount;
+                        else
+                        {
+                            var sum = XactHelpers.Random.Next(_totalWeights);
+                            for (var i=0; i < trackCount; i++)
+                            {
+                                sum -= _weights[i];
+                                if (sum <= 0)
+                                {
+                                    _wavIndex = i;
+                                    break;
+                                }
+                            }
+                        }
+                        break;
+
+                    case VariationType.RandomNoImmediateRepeats:
+                    {
+                        if (_weights == null || trackCount == 1)
+                            _wavIndex = XactHelpers.Random.Next() % trackCount;
+                        else
+                        {
+                            var last = _wavIndex;
+                            var sum = XactHelpers.Random.Next(_totalWeights);
+                            for (var i=0; i < trackCount; i++)
+                            {
+                                sum -= _weights[i];
+                                if (sum <= 0)
+                                {
+                                    _wavIndex = i;
+                                    break;
+                                }
+                            }
+
+                            if (_wavIndex == last)
+                                _wavIndex = (_wavIndex + 1) % trackCount;
+                        }
+                        break;
+                    }
+
+                    case VariationType.Shuffle:
+                        // TODO: Need some sort of deck implementation.
+                        _wavIndex = XactHelpers.Random.Next() % trackCount;
+                        break;
+                };
+            }
+
+            _wav = _soundBank.GetSoundEffectInstance(_waveBanks[_wavIndex], _tracks[_wavIndex], out _streaming);
+            if (_wav == null)
+            {
+                // We couldn't create a sound effect instance, most likely
+                // because we've reached the sound pool limits.
+                return;
+            }
+
+            // Do all the randoms before we play.
+            if (_volumeVar.HasValue)
+                _trackVolume = _volumeVar.Value.X + ((float)XactHelpers.Random.NextDouble() * _volumeVar.Value.Y);
+            if (_pitchVar.HasValue)
+                _trackPitch = _pitchVar.Value.X + ((float)XactHelpers.Random.NextDouble() * _pitchVar.Value.Y);
+            if (_clip.FilterEnabled)
+            {
+                if (_filterVar.HasValue)
+                {
+                    _trackFilterFrequency = _filterVar.Value.X + ((float)XactHelpers.Random.NextDouble() * _filterVar.Value.Y);
+                    _trackFilterQFactor = _filterVar.Value.Z + ((float)XactHelpers.Random.NextDouble() * _filterVar.Value.W);
+                }
+                else
+                {
+                    _trackFilterFrequency = _clip.FilterFrequency;
+                    _trackFilterQFactor = _clip.FilterQ;                
+                }
+            }
+ 
+            // This is a shortcut for infinite looping of a single track.
+            _wav.IsLooped = _loopCount == 255 && trackCount == 1;
+
+            // Update all the wave states then play.
+            UpdateState();
+            _wav.Play();
+        }
+
+        public override void Stop()
+        {
+            if (_wav != null)
+            {
+                _wav.Stop();
+                if (_streaming)
+                    _wav.Dispose();
+				else
+                	_wav._isXAct = false;				
+                _wav = null;
+            }
+            _loopIndex = 0;
+        }
+
+        public override void Pause() 
+        {
+            if (_wav != null)
+                _wav.Pause();
+        }
+
+        public override void Resume()
+        {
+            if (_wav != null && _wav.State == SoundState.Paused)
+                _wav.Resume();
+        }
+
+        public override void SetTrackVolume(float volume)
+        {
+            _clipVolume = volume;
+            if (_wav != null)
+                _wav.Volume = _trackVolume * _clipVolume;
+        }
+
+        public override void SetTrackPan(float pan)
+        {
+            if (_wav != null)
+                _wav.Pan = pan;
+        }
+
+        public override void SetState(float volume, float pitch, float reverbMix, float? filterFrequency, float? filterQFactor)
+        {
+            _clipVolume = volume;
+            _clipPitch = pitch;
+            _clipReverbMix = reverbMix;
+
+            // The RPC filter overrides the randomized track filter.
+            if (filterFrequency.HasValue)
+                _trackFilterFrequency = filterFrequency.Value;
+            if (filterQFactor.HasValue)
+                _trackFilterQFactor = filterQFactor.Value;
+
+            if (_wav != null)
+                UpdateState();
+        }
+
+        private void UpdateState()
+        {
+            _wav.Volume = _trackVolume * _clipVolume;
+            _wav.Pitch = _trackPitch + _clipPitch;
+
+            if (_clip.UseReverb)
+                _wav.PlatformSetReverbMix(_clipReverbMix);
+            if (_clip.FilterEnabled)
+                _wav.PlatformSetFilter(_clip.FilterMode, _trackFilterQFactor, _trackFilterFrequency);
+        }
+
+        public override void SetFade(float fadeInDuration, float fadeOutDuration)
+        {
+            // TODO
+        }
+
+        public override bool Update(float dt)
+        {
+            if (_wav != null && _wav.State == SoundState.Stopped)
+            {
+                // If we're not looping or reached our loop 
+                // limit then we can stop.
+                if (_loopCount == 0 || _loopIndex >= _loopCount)
+                {
+                    if (_streaming)
+                        _wav.Dispose();
+					else
+	                    _wav._isXAct = false;						
+                    _wav = null;
+                    _loopIndex = 0;
+                }
+                else
+                {
+                    // Increment the loop count if it isn't infinite.
+                    if (_loopCount != 255)
+                        ++_loopIndex;
+
+                    // Play the next track.
+                    Play(_newWaveOnLoop);
+                }
+            }
+
+            return _wav != null;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/Xact/ReverbSettings.cs b/MonoGame.Framework/Audio/Xact/ReverbSettings.cs
new file mode 100644
index 00000000000..6c414f5f596
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/ReverbSettings.cs
@@ -0,0 +1,69 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    class ReverbSettings
+    {
+        private readonly DspParameter[] _parameters = new DspParameter[22];
+
+        public ReverbSettings(BinaryReader reader)
+        {
+            _parameters[0] = new DspParameter(reader); // ReflectionsDelayMs
+            _parameters[1] = new DspParameter(reader); // ReverbDelayMs
+            _parameters[2] = new DspParameter(reader); // PositionLeft
+            _parameters[3] = new DspParameter(reader); // PositionRight
+            _parameters[4] = new DspParameter(reader); // PositionLeftMatrix
+            _parameters[5] = new DspParameter(reader); // PositionRightMatrix
+            _parameters[6] = new DspParameter(reader); // EarlyDiffusion
+            _parameters[7] = new DspParameter(reader); // LateDiffusion
+            _parameters[8] = new DspParameter(reader); // LowEqGain
+            _parameters[9] = new DspParameter(reader); // LowEqCutoff
+            _parameters[10] = new DspParameter(reader); // HighEqGain
+            _parameters[11] = new DspParameter(reader); // HighEqCutoff
+            _parameters[12] = new DspParameter(reader); // RearDelayMs
+            _parameters[13] = new DspParameter(reader); // RoomFilterFrequencyHz
+            _parameters[14] = new DspParameter(reader); // RoomFilterMainDb
+            _parameters[15] = new DspParameter(reader); // RoomFilterHighFrequencyDb
+            _parameters[16] = new DspParameter(reader); // ReflectionsGainDb
+            _parameters[17] = new DspParameter(reader); // ReverbGainDb
+            _parameters[18] = new DspParameter(reader); // DecayTimeSec
+            _parameters[19] = new DspParameter(reader); // DensityPct
+            _parameters[20] = new DspParameter(reader); // RoomSizeFeet
+            _parameters[21] = new DspParameter(reader); // WetDryMixPct
+        }
+
+        public float this[int index]
+        {
+            get { return _parameters[index].Value; }
+            set { _parameters[index].SetValue(value); }
+        }
+
+        public float ReflectionsDelayMs { get { return _parameters[0].Value; } }
+        public float ReverbDelayMs { get { return _parameters[1].Value; } }
+        public float PositionLeft { get { return _parameters[2].Value; } }
+        public float PositionRight { get { return _parameters[3].Value; } }
+        public float PositionLeftMatrix { get { return _parameters[4].Value; } }
+        public float PositionRightMatrix { get { return _parameters[5].Value; } }
+        public float EarlyDiffusion { get { return _parameters[6].Value; } }
+        public float LateDiffusion { get { return _parameters[7].Value; } }
+        public float LowEqGain { get { return _parameters[8].Value; } }
+        public float LowEqCutoff { get { return _parameters[9].Value; } }
+        public float HighEqGain { get { return _parameters[10].Value; } }
+        public float HighEqCutoff { get { return _parameters[11].Value; } }
+        public float RearDelayMs { get { return _parameters[12].Value; } }
+        public float RoomFilterFrequencyHz { get { return _parameters[13].Value; } }
+        public float RoomFilterMainDb { get { return _parameters[14].Value; } }
+        public float RoomFilterHighFrequencyDb { get { return _parameters[15].Value; } }
+        public float ReflectionsGainDb { get { return _parameters[16].Value; } }
+        public float ReverbGainDb { get { return _parameters[17].Value; } }
+        public float DecayTimeSec { get { return _parameters[18].Value; } }
+        public float DensityPct { get { return _parameters[19].Value; } }
+        public float RoomSizeFeet { get { return _parameters[20].Value; } }
+        public float WetDryMixPct { get { return _parameters[21].Value; } }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Audio/Xact/RpcCurve.cs b/MonoGame.Framework/Audio/Xact/RpcCurve.cs
new file mode 100644
index 00000000000..bba1861d8bf
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/RpcCurve.cs
@@ -0,0 +1,47 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    struct RpcCurve
+    {
+        public uint FileOffset;
+        public int Variable;
+        public bool IsGlobal;
+        public RpcParameter Parameter;
+        public RpcPoint[] Points;
+
+        public float Evaluate(float position)
+        {
+            // TODO: We need to implement the different RpcPointTypes.
+
+            var first = Points[0];
+            if (position <= first.Position)
+                return first.Value;
+
+            var second = Points[Points.Length - 1];
+            if (position >= second.Position)
+                return second.Value;
+
+            for (var i = 1; i < Points.Length; ++i)
+            {
+                second = Points[i];
+                if (second.Position >= position)
+                    break;
+
+                first = second;
+            }
+
+            switch (first.Type)
+            {
+                default:
+                case RpcPointType.Linear:
+                {
+                    var t = (position - first.Position) / (second.Position - first.Position);
+                    return first.Value + ((second.Value - first.Value) * t);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Audio/Xact/RpcParameter.cs b/MonoGame.Framework/Audio/Xact/RpcParameter.cs
new file mode 100644
index 00000000000..20b3d34d2fd
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/RpcParameter.cs
@@ -0,0 +1,16 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    enum RpcParameter
+    {
+        Volume,
+        Pitch,
+        ReverbSend,
+        FilterFrequency,
+        FilterQFactor,
+        NumParameters,
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Audio/Xact/RpcPoint.cs b/MonoGame.Framework/Audio/Xact/RpcPoint.cs
new file mode 100644
index 00000000000..68be3816de9
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/RpcPoint.cs
@@ -0,0 +1,13 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    struct RpcPoint 
+    {
+        public RpcPointType Type;
+        public float Position;
+        public float Value;
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Audio/Xact/RpcPointType.cs b/MonoGame.Framework/Audio/Xact/RpcPointType.cs
new file mode 100644
index 00000000000..f70e1e949a2
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/RpcPointType.cs
@@ -0,0 +1,14 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    enum RpcPointType 
+    {
+        Linear,
+        Fast,
+        Slow,
+        SinCos
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Audio/Xact/RpcVariable.cs b/MonoGame.Framework/Audio/Xact/RpcVariable.cs
new file mode 100644
index 00000000000..39b76400f58
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/RpcVariable.cs
@@ -0,0 +1,46 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    struct RpcVariable 
+    {
+        public string Name;
+        public float Value;
+        public byte Flags;
+        public float InitValue;
+        public float MaxValue;
+        public float MinValue;
+
+        public bool IsPublic
+        {
+            get { return (Flags & 0x1) != 0; }
+        }
+
+        public bool IsReadOnly
+        {
+            get { return (Flags & 0x2) != 0; }
+        }
+
+        public bool IsGlobal
+        {
+            get { return (Flags & 0x4) == 0; }
+        }
+
+        public bool IsReserved
+        {
+            get { return (Flags & 0x8) != 0; }
+        }
+
+        public void SetValue(float value)
+        {
+            if (value < MinValue)
+                Value = MinValue;
+            else if (value > MaxValue)
+                Value = MaxValue;
+            else
+                Value = value;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Audio/Xact/SoundBank.cs b/MonoGame.Framework/Audio/Xact/SoundBank.cs
new file mode 100644
index 00000000000..afd2048aac5
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/SoundBank.cs
@@ -0,0 +1,355 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Diagnostics;
+using System.Collections.Generic;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>Represents a collection of Cues.</summary>
+    public class SoundBank : IDisposable
+    {
+        readonly AudioEngine _audioengine;
+        readonly string[] _waveBankNames;
+        readonly WaveBank[] _waveBanks;
+
+        readonly float [] defaultProbability = new float [1] { 1.0f };
+        readonly Dictionary<string, XactSound[]> _sounds = new Dictionary<string, XactSound[]>();
+        readonly Dictionary<string, float []> _probabilities = new Dictionary<string, float []> ();
+
+        /// <summary>
+        /// Is true if the SoundBank has any live Cues in use.
+        /// </summary>
+        public bool IsInUse { get; private set; }
+
+        /// <param name="audioEngine">AudioEngine that will be associated with this sound bank.</param>
+        /// <param name="fileName">Path to a .xsb SoundBank file.</param>
+        public SoundBank(AudioEngine audioEngine, string fileName)
+        {
+            if (audioEngine == null)
+                throw new ArgumentNullException("audioEngine");
+            if (string.IsNullOrEmpty(fileName))
+                throw new ArgumentNullException("fileName");
+
+            _audioengine = audioEngine;
+
+            using (var stream = AudioEngine.OpenStream(fileName, true))
+            using (var reader = new BinaryReader(stream))
+            {
+                // Thanks to Liandril for "xactxtract" for some of the offsets.
+
+                uint magic = reader.ReadUInt32();
+                if (magic != 0x4B424453) //"SDBK"
+                    throw new Exception ("Bad soundbank format");
+
+                reader.ReadUInt16(); // toolVersion
+
+                uint formatVersion = reader.ReadUInt16();
+                if (formatVersion != 43)
+                    Debug.WriteLine("Warning: SoundBank format {0} not supported.", formatVersion);
+
+                reader.ReadUInt16(); // crc, TODO: Verify crc (FCS16)
+
+                reader.ReadUInt32(); // lastModifiedLow
+                reader.ReadUInt32(); // lastModifiedHigh
+                reader.ReadByte(); // platform ???
+
+                uint numSimpleCues = reader.ReadUInt16();
+                uint numComplexCues = reader.ReadUInt16();
+                reader.ReadUInt16(); //unkn
+                reader.ReadUInt16(); // numTotalCues
+                uint numWaveBanks = reader.ReadByte();
+                reader.ReadUInt16(); // numSounds
+                uint cueNameTableLen = reader.ReadUInt16();
+                reader.ReadUInt16(); //unkn
+
+                uint simpleCuesOffset = reader.ReadUInt32();
+                uint complexCuesOffset = reader.ReadUInt32(); //unkn
+                uint cueNamesOffset = reader.ReadUInt32();
+                reader.ReadUInt32(); //unkn
+                reader.ReadUInt32(); // variationTablesOffset
+                reader.ReadUInt32(); //unkn
+                uint waveBankNameTableOffset = reader.ReadUInt32();
+                reader.ReadUInt32(); // cueNameHashTableOffset
+                reader.ReadUInt32(); // cueNameHashValsOffset
+                reader.ReadUInt32(); // soundsOffset
+                    
+                //name = System.Text.Encoding.UTF8.GetString(soundbankreader.ReadBytes(64),0,64).Replace("\0","");
+
+                //parse wave bank name table
+                stream.Seek(waveBankNameTableOffset, SeekOrigin.Begin);
+                _waveBanks = new WaveBank[numWaveBanks];
+                _waveBankNames = new string[numWaveBanks];
+                for (int i=0; i<numWaveBanks; i++)
+                    _waveBankNames[i] = System.Text.Encoding.UTF8.GetString(reader.ReadBytes(64), 0, 64).Replace("\0", "");
+                    
+                //parse cue name table
+                stream.Seek(cueNamesOffset, SeekOrigin.Begin);
+                string[] cueNames = System.Text.Encoding.UTF8.GetString(reader.ReadBytes((int)cueNameTableLen), 0, (int)cueNameTableLen).Split('\0');
+
+                // Simple cues
+                if (numSimpleCues > 0)
+                {
+                    stream.Seek(simpleCuesOffset, SeekOrigin.Begin);
+                    for (int i = 0; i < numSimpleCues; i++)
+                    {
+                        reader.ReadByte(); // flags
+                        uint soundOffset = reader.ReadUInt32();
+
+                        var oldPosition = stream.Position;
+                        stream.Seek(soundOffset, SeekOrigin.Begin);
+                        XactSound sound = new XactSound(audioEngine, this, reader);
+                        stream.Seek(oldPosition, SeekOrigin.Begin);
+
+                        _sounds.Add(cueNames [i], new XactSound [] { sound } );
+                        _probabilities.Add (cueNames [i], defaultProbability);  
+                    }
+                }
+                    
+                // Complex cues
+                if (numComplexCues > 0)
+                {
+                    stream.Seek(complexCuesOffset, SeekOrigin.Begin);
+                    for (int i = 0; i < numComplexCues; i++)
+                    {
+                        byte flags = reader.ReadByte();
+                        if (((flags >> 2) & 1) != 0)
+                        {
+                            uint soundOffset = reader.ReadUInt32();
+                            reader.ReadUInt32(); //unkn
+
+                            var oldPosition = stream.Position;
+                            stream.Seek(soundOffset, SeekOrigin.Begin);
+                            XactSound sound = new XactSound(audioEngine, this, reader);
+                            stream.Seek(oldPosition, SeekOrigin.Begin);
+
+                            _sounds.Add (cueNames [numSimpleCues + i], new XactSound [] { sound });
+                            _probabilities.Add (cueNames [numSimpleCues + i], defaultProbability);
+                        }
+                        else
+                        {
+                            uint variationTableOffset = reader.ReadUInt32();
+                            reader.ReadUInt32(); // transitionTableOffset
+
+                            //parse variation table
+                            long savepos = stream.Position;
+                            stream.Seek(variationTableOffset, SeekOrigin.Begin);
+
+                            uint numEntries = reader.ReadUInt16();
+                            uint variationflags = reader.ReadUInt16();
+                            reader.ReadByte();
+                            reader.ReadUInt16();
+                            reader.ReadByte();
+
+                            XactSound[] cueSounds = new XactSound[numEntries];
+                            float[] probs = new float[numEntries];
+
+                            uint tableType = (variationflags >> 3) & 0x7;
+                            for (int j = 0; j < numEntries; j++)
+                            {
+                                switch (tableType)
+                                {
+                                    case 0: //Wave
+                                        {
+                                            int trackIndex = reader.ReadUInt16();
+                                            int waveBankIndex = reader.ReadByte();
+                                            reader.ReadByte(); // weightMin
+                                            reader.ReadByte(); // weightMax
+
+                                            cueSounds[j] = new XactSound(this, waveBankIndex, trackIndex);
+                                            break;
+                                        }
+                                    case 1:
+                                        {
+                                            uint soundOffset = reader.ReadUInt32();
+                                            reader.ReadByte(); // weightMin
+                                            reader.ReadByte(); // weightMax
+
+                                            var oldPosition = stream.Position;
+                                            stream.Seek(soundOffset, SeekOrigin.Begin);
+                                            cueSounds[j] = new XactSound(audioEngine, this, reader);
+                                            stream.Seek(oldPosition, SeekOrigin.Begin);
+                                            break;
+                                        }
+                                    case 3:
+                                        {
+                                            uint soundOffset = reader.ReadUInt32();
+                                            reader.ReadSingle(); // weightMin
+                                            reader.ReadSingle(); // weightMax
+                                            reader.ReadUInt32(); // flags
+
+                                            var oldPosition = stream.Position;
+                                            stream.Seek(soundOffset, SeekOrigin.Begin);
+                                            cueSounds[j] = new XactSound(audioEngine, this, reader);
+                                            stream.Seek(oldPosition, SeekOrigin.Begin);
+                                            break;
+                                        }
+                                    case 4: //CompactWave
+                                        {
+                                            int trackIndex = reader.ReadUInt16();
+                                            int waveBankIndex = reader.ReadByte();
+                                            cueSounds[j] = new XactSound(this, waveBankIndex, trackIndex);
+                                            break;
+                                        }
+                                    default:
+                                        throw new NotSupportedException();
+                                }
+                            }
+
+                            stream.Seek(savepos, SeekOrigin.Begin);
+
+                            _sounds.Add (cueNames [numSimpleCues + i], cueSounds);
+                            _probabilities.Add (cueNames [numSimpleCues + i], probs);
+                        }
+
+                        // Instance limiting
+                        reader.ReadByte(); //instanceLimit
+                        reader.ReadUInt16(); //fadeInSec, divide by 1000.0f
+                        reader.ReadUInt16(); //fadeOutSec, divide by 1000.0f
+                        reader.ReadByte(); //instanceFlags
+                    }
+                }
+            }
+        }
+
+        internal SoundEffectInstance GetSoundEffectInstance(int waveBankIndex, int trackIndex, out bool streaming)
+        {
+            var waveBank = _waveBanks[waveBankIndex];
+
+            // If the wave bank has not been resolved then do so now.
+            if (waveBank == null)
+            {
+                var name = _waveBankNames[waveBankIndex];
+                if (!_audioengine.Wavebanks.TryGetValue(name, out waveBank))
+                    throw new Exception("The wave bank '" + name + "' was not found!");
+                _waveBanks[waveBankIndex] = waveBank;                
+            }
+
+            return waveBank.GetSoundEffectInstance(trackIndex, out streaming);
+        }
+        
+        /// <summary>
+        /// Returns a pooled Cue object.
+        /// </summary>
+        /// <param name="name">Friendly name of the cue to get.</param>
+        /// <returns>a unique Cue object from a pool.</returns>
+        /// <remarks>
+        /// <para>Cue instances are unique, even when sharing the same name. This allows multiple instances to simultaneously play.</para>
+        /// </remarks>
+        public Cue GetCue(string name)
+        {
+            if (string.IsNullOrEmpty(name))
+                throw new ArgumentNullException("name");
+
+            XactSound[] sounds;
+            if (!_sounds.TryGetValue(name, out sounds))
+                throw new ArgumentException();
+
+            float [] probs;
+            if (!_probabilities.TryGetValue (name, out probs))
+                throw new ArgumentException ();
+
+            IsInUse = true;
+
+            var cue = new Cue (_audioengine, name, sounds, probs);
+            cue.Prepare();
+            return cue;
+        }
+        
+        /// <summary>
+        /// Plays a cue.
+        /// </summary>
+        /// <param name="name">Name of the cue to play.</param>
+        public void PlayCue(string name)
+        {
+            if (string.IsNullOrEmpty(name))
+                throw new ArgumentNullException("name");
+
+            XactSound[] sounds;
+            if (!_sounds.TryGetValue(name, out sounds))
+                throw new ArgumentException();
+
+            float [] probs;
+            if (!_probabilities.TryGetValue (name, out probs))
+                throw new ArgumentException ();
+
+            IsInUse = true;
+            var cue = new Cue (_audioengine, name, sounds, probs);
+            cue.Prepare();
+            cue.Play();
+        }
+
+        /// <summary>
+        /// Plays a cue with static 3D positional information.
+        /// </summary>
+        /// <remarks>
+        /// Commonly used for short lived effects.  To dynamically change the 3D 
+        /// positional information on a cue over time use <see cref="GetCue"/> and <see cref="Cue.Apply3D"/>.</remarks>
+        /// <param name="name">The name of the cue to play.</param>
+        /// <param name="listener">The listener state.</param>
+        /// <param name="emitter">The cue emitter state.</param>
+        public void PlayCue(string name, AudioListener listener, AudioEmitter emitter)
+        {
+            if (string.IsNullOrEmpty(name))
+                throw new ArgumentNullException("name");
+
+            XactSound[] sounds;
+            if (!_sounds.TryGetValue(name, out sounds))
+                throw new InvalidOperationException();
+
+            float [] probs;
+            if (!_probabilities.TryGetValue (name, out probs))
+                throw new ArgumentException ();
+
+            IsInUse = true;
+
+            var cue = new Cue (_audioengine, name, sounds, probs);
+            cue.Prepare();
+            cue.Apply3D(listener, emitter);
+            cue.Play();
+        }
+
+        /// <summary>
+        /// This event is triggered when the SoundBank is disposed.
+        /// </summary>
+        public event EventHandler<EventArgs> Disposing;
+
+        /// <summary>
+        /// Is true if the SoundBank has been disposed.
+        /// </summary>
+        public bool IsDisposed { get; private set; }
+
+        /// <summary>
+        /// Disposes the SoundBank.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        ~SoundBank()
+        {
+            Dispose(false);
+        }
+
+        private void Dispose(bool disposing)
+        {
+            if (IsDisposed)
+                return;
+
+            IsDisposed = true;
+
+            if (disposing)
+            {
+                IsInUse = false;
+                EventHelpers.Raise(this, Disposing, EventArgs.Empty);
+            }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/Xact/VolumeEvent.cs b/MonoGame.Framework/Audio/Xact/VolumeEvent.cs
new file mode 100644
index 00000000000..49adbf9dc29
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/VolumeEvent.cs
@@ -0,0 +1,60 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+	class VolumeEvent : ClipEvent
+	{
+	    private readonly float _volume;
+
+        public VolumeEvent(XactClip clip, float timeStamp, float randomOffset, float volume)
+            : base(clip, timeStamp, randomOffset)
+        {
+            _volume = volume;
+        }
+
+		public override void Play() 
+        {
+            _clip.SetVolume(_volume);
+        }
+
+	    public override void Stop()
+	    {
+	    }
+
+	    public override void Pause() 
+        {
+		}
+
+		public override void Resume()
+		{
+		}
+
+		public override void SetTrackVolume(float volume)
+        {
+		}
+
+	    public override void SetTrackPan(float pan)
+	    {
+	    }
+
+	    public override void SetState(float volume, float pitch, float reverbMix, float? filterFrequency, float? filterQFactor)
+	    {
+	    }
+
+	    public override bool Update(float dt)
+	    {
+	        return false;
+	    }
+
+	    public override void SetFade(float fadeInDuration, float fadeOutDuration)
+        {
+        }
+
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/Xact/WaveBank.Default.cs b/MonoGame.Framework/Audio/Xact/WaveBank.Default.cs
new file mode 100644
index 00000000000..a495a94190e
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/WaveBank.Default.cs
@@ -0,0 +1,17 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    partial class WaveBank
+    {
+        private SoundEffectInstance PlatformCreateStream(StreamInfo stream)
+        {
+            throw new NotImplementedException("XACT streaming is not implemented on this platform.");
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/Xact/WaveBank.cs b/MonoGame.Framework/Audio/Xact/WaveBank.cs
new file mode 100644
index 00000000000..165e9a7ec12
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/WaveBank.cs
@@ -0,0 +1,420 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>Represents a collection of wave files.</summary>
+    public partial class WaveBank : IDisposable
+    {
+        private readonly SoundEffect[] _sounds;
+        private readonly StreamInfo[] _streams;
+        private readonly string _bankName;
+        private readonly string _waveBankFileName;
+        private readonly bool _streaming;
+        private readonly int _offset;
+        private readonly int _packetSize;
+
+        private readonly int _version;
+        private readonly int _playRegionOffset;
+
+        struct Segment
+        {
+            public int Offset;
+            public int Length;
+        }
+
+        struct WaveBankHeader
+        {
+            public int Version;
+            public Segment[] Segments;
+        }
+
+        struct WaveBankData
+        {
+            public int    Flags;                                // Bank flags
+            public int    EntryCount;                           // Number of entries in the bank
+            public string BankName;                             // Bank friendly name
+            public int    EntryMetaDataElementSize;             // Size of each entry meta-data element, in bytes
+            public int    EntryNameElementSize;                 // Size of each entry name element, in bytes
+            public int    Alignment;                            // Entry alignment, in bytes
+            public int    CompactFormat;                        // Format data for compact bank
+            public int    BuildTime;                            // Build timestamp
+        }
+
+        struct StreamInfo
+        {
+            public int Format;
+            public int FileOffset;
+            public int FileLength;
+            public int LoopStart;
+            public int LoopLength;
+        }
+
+        private const int Flag_EntryNames = 0x00010000; // Bank includes entry names
+        private const int Flag_Compact = 0x00020000; // Bank uses compact format
+        private const int Flag_SyncDisabled = 0x00040000; // Bank is disabled for audition sync
+        private const int Flag_SeekTables = 0x00080000; // Bank includes seek tables.
+        private const int Flag_Mask = 0x000F0000;
+        
+        /// <summary>
+        /// </summary>
+        public bool IsInUse { get; private set; }
+
+        /// <summary>
+        /// </summary>
+        public bool IsPrepared { get; private set; }
+
+        /// <param name="audioEngine">Instance of the AudioEngine to associate this wave bank with.</param>
+        /// <param name="nonStreamingWaveBankFilename">Path to the .xwb file to load.</param>
+        /// <remarks>This constructor immediately loads all wave data into memory at once.</remarks>
+        public WaveBank(AudioEngine audioEngine, string nonStreamingWaveBankFilename)
+            : this(audioEngine, nonStreamingWaveBankFilename, false, 0, 0)
+        {
+        }
+
+        private WaveBank(AudioEngine audioEngine, string waveBankFilename, bool streaming, int offset, int packetsize)
+        {
+            if (audioEngine == null)
+                throw new ArgumentNullException("audioEngine");
+            if (string.IsNullOrEmpty(waveBankFilename))
+                throw new ArgumentNullException("nonStreamingWaveBankFilename");
+
+            // Is this a streaming wavebank?
+            if (streaming)
+            {
+                if (offset != 0)
+                    throw new ArgumentException("We only support a zero offset in streaming banks.", "offset");
+                if (packetsize < 2)
+                    throw new ArgumentException("The packet size must be greater than 2.", "packetsize");
+
+                _streaming = true;
+                _offset = offset;
+                _packetSize = packetsize;
+            }
+
+            //XWB PARSING
+            //Adapted from MonoXNA
+            //Originally adaped from Luigi Auriemma's unxwb
+            
+            WaveBankHeader wavebankheader;
+            WaveBankData wavebankdata;
+
+            wavebankdata.EntryNameElementSize = 0;
+            wavebankdata.CompactFormat = 0;
+            wavebankdata.Alignment = 0;
+            wavebankdata.BuildTime = 0;
+
+            int wavebank_offset = 0;
+
+            _waveBankFileName = waveBankFilename;
+
+            BinaryReader reader = new BinaryReader(AudioEngine.OpenStream(waveBankFilename));
+
+            reader.ReadBytes(4);
+
+            _version = wavebankheader.Version = reader.ReadInt32();
+
+            int last_segment = 4;
+            //if (wavebankheader.Version == 1) goto WAVEBANKDATA;
+            if (wavebankheader.Version <= 3) last_segment = 3;
+            if (wavebankheader.Version >= 42) reader.ReadInt32();    // skip HeaderVersion
+
+            wavebankheader.Segments = new Segment[5];
+
+            for (int i = 0; i <= last_segment; i++)
+            {
+                wavebankheader.Segments[i].Offset = reader.ReadInt32();
+                wavebankheader.Segments[i].Length = reader.ReadInt32();
+            }
+
+            reader.BaseStream.Seek(wavebankheader.Segments[0].Offset, SeekOrigin.Begin);
+
+            //WAVEBANKDATA:
+
+            wavebankdata.Flags = reader.ReadInt32();
+            wavebankdata.EntryCount = reader.ReadInt32();
+
+            if ((wavebankheader.Version == 2) || (wavebankheader.Version == 3))
+            {
+                wavebankdata.BankName = System.Text.Encoding.UTF8.GetString(reader.ReadBytes(16),0,16).Replace("\0", "");
+            }
+            else
+            {
+                wavebankdata.BankName = System.Text.Encoding.UTF8.GetString(reader.ReadBytes(64),0,64).Replace("\0", "");
+            }
+
+            _bankName = wavebankdata.BankName;
+
+            if (wavebankheader.Version == 1)
+            {
+                //wavebank_offset = (int)ftell(fd) - file_offset;
+                wavebankdata.EntryMetaDataElementSize = 20;
+            }
+            else
+            {
+                wavebankdata.EntryMetaDataElementSize = reader.ReadInt32();
+                wavebankdata.EntryNameElementSize = reader.ReadInt32();
+                wavebankdata.Alignment = reader.ReadInt32();
+                wavebank_offset = wavebankheader.Segments[1].Offset; //METADATASEGMENT
+            }
+
+            if ((wavebankdata.Flags & Flag_Compact) != 0)
+            {
+                reader.ReadInt32(); // compact_format
+            }
+
+            _playRegionOffset = wavebankheader.Segments[last_segment].Offset;
+            if (_playRegionOffset == 0)
+            {
+                _playRegionOffset =
+                    wavebank_offset +
+                    (wavebankdata.EntryCount * wavebankdata.EntryMetaDataElementSize);
+            }
+            
+            int segidx_entry_name = 2;
+            if (wavebankheader.Version >= 42) segidx_entry_name = 3;
+            
+            if ((wavebankheader.Segments[segidx_entry_name].Offset != 0) &&
+                (wavebankheader.Segments[segidx_entry_name].Length != 0))
+            {
+                if (wavebankdata.EntryNameElementSize == -1) wavebankdata.EntryNameElementSize = 0;
+                byte[] entry_name = new byte[wavebankdata.EntryNameElementSize + 1];
+                entry_name[wavebankdata.EntryNameElementSize] = 0;
+            }
+
+            _sounds = new SoundEffect[wavebankdata.EntryCount];
+            _streams = new StreamInfo[wavebankdata.EntryCount];
+
+            reader.BaseStream.Seek(wavebank_offset, SeekOrigin.Begin);
+
+            // The compact format requires us to load stuff differently.
+            var isCompactFormat = (wavebankdata.Flags & Flag_Compact) != 0;
+            if (isCompactFormat)
+            {
+                // Load the sound data offset table from disk.
+                for (var i = 0; i < wavebankdata.EntryCount; i++)
+                {
+                    var len = reader.ReadInt32();
+                    _streams[i].Format = wavebankdata.CompactFormat;
+                    _streams[i].FileOffset = (len & ((1 << 21) - 1))*wavebankdata.Alignment;
+                }
+
+                // Now figure out the sound data lengths.
+                for (var i = 0; i < wavebankdata.EntryCount; i++)
+                {
+                    int nextOffset;
+                    if (i == (wavebankdata.EntryCount - 1))
+                        nextOffset = wavebankheader.Segments[last_segment].Length;
+                    else
+                        nextOffset = _streams[i + 1].FileOffset;
+
+                    // The next and current offsets used to calculate the length.
+                    _streams[i].FileLength = nextOffset - _streams[i].FileOffset;
+                }
+            }
+            else
+            {
+                for (var i = 0; i < wavebankdata.EntryCount; i++)
+                {
+                    var info = new StreamInfo();
+                    if (wavebankheader.Version == 1)
+                    {
+                        info.Format = reader.ReadInt32();
+                        info.FileOffset = reader.ReadInt32();
+                        info.FileLength = reader.ReadInt32();
+                        info.LoopStart = reader.ReadInt32();
+                        info.LoopLength = reader.ReadInt32();
+                    }
+                    else
+                    {
+                        var flagsAndDuration = reader.ReadInt32(); // Unused
+
+                        if (wavebankdata.EntryMetaDataElementSize >= 8)
+                            info.Format = reader.ReadInt32();
+                        if (wavebankdata.EntryMetaDataElementSize >= 12)
+                            info.FileOffset = reader.ReadInt32();
+                        if (wavebankdata.EntryMetaDataElementSize >= 16)
+                            info.FileLength = reader.ReadInt32();
+                        if (wavebankdata.EntryMetaDataElementSize >= 20)
+                            info.LoopStart = reader.ReadInt32();
+                        if (wavebankdata.EntryMetaDataElementSize >= 24)
+                            info.LoopLength = reader.ReadInt32();
+                    }
+
+                    // TODO: What is this doing?
+                    if (wavebankdata.EntryMetaDataElementSize < 24)
+                    {
+                        if (info.FileLength != 0)
+                            info.FileLength = wavebankheader.Segments[last_segment].Length;
+                    }
+
+                    _streams[i] = info;
+                }
+            }
+
+            // If this isn't a streaming wavebank then load all the sounds now.
+            if (!_streaming)
+            {
+                for (var i = 0; i < _streams.Length; i++)
+                {
+                    var info = _streams[i];
+                    
+                    // Read the data.
+                    reader.BaseStream.Seek(info.FileOffset + _playRegionOffset, SeekOrigin.Begin);
+                    var audiodata = reader.ReadBytes(info.FileLength);
+
+                    // Decode the format information.
+                    MiniFormatTag codec;
+                    int channels, rate, alignment;
+                    DecodeFormat(info.Format, out codec, out channels, out rate, out alignment);
+
+                    // Call the special constuctor on SoundEffect to sort it out.
+                    _sounds[i] = new SoundEffect(codec, audiodata, channels, rate, alignment, info.LoopStart, info.LoopLength);                
+                }
+
+                _streams = null;
+            }
+            
+            audioEngine.Wavebanks[_bankName] = this;
+
+            IsPrepared = true;
+        }
+
+        private void DecodeFormat(int format, out MiniFormatTag codec, out int channels, out int rate, out int alignment)
+        {
+            if (_version == 1)
+            {
+                // I'm not 100% sure if the following is correct
+                // version 1:
+                // 1 00000000 000101011000100010 0 001 0
+                // | |         |                 | |   |
+                // | |         |                 | |   wFormatTag
+                // | |         |                 | nChannels
+                // | |         |                 ???
+                // | |         nSamplesPerSec
+                // | wBlockAlign
+                // wBitsPerSample
+
+                codec = (MiniFormatTag)((format) & ((1 << 1) - 1));
+                channels = (format >> (1)) & ((1 << 3) - 1);
+                rate = (format >> (1 + 3 + 1)) & ((1 << 18) - 1);
+                alignment = (format >> (1 + 3 + 1 + 18)) & ((1 << 8) - 1);
+                //bits = (format >> (1 + 3 + 1 + 18 + 8)) & ((1 << 1) - 1);
+
+                /*} else if(wavebankheader.dwVersion == 23) { // I'm not 100% sure if the following is correct
+                    // version 23:
+                    // 1000000000 001011101110000000 001 1
+                    // | |        |                  |   |
+                    // | |        |                  |   ???
+                    // | |        |                  nChannels?
+                    // | |        nSamplesPerSec
+                    // | ???
+                    // !!!UNKNOWN FORMAT!!!
+
+                    //codec = -1;
+                    //chans = (wavebankentry.Format >>  1) & ((1 <<  3) - 1);
+                    //rate  = (wavebankentry.Format >>  4) & ((1 << 18) - 1);
+                    //bits  = (wavebankentry.Format >> 31) & ((1 <<  1) - 1);
+                    codec = (wavebankentry.Format                    ) & ((1 <<  1) - 1);
+                    chans = (wavebankentry.Format >> (1)             ) & ((1 <<  3) - 1);
+                    rate  = (wavebankentry.Format >> (1 + 3)         ) & ((1 << 18) - 1);
+                    align = (wavebankentry.Format >> (1 + 3 + 18)    ) & ((1 <<  9) - 1);
+                    bits  = (wavebankentry.Format >> (1 + 3 + 18 + 9)) & ((1 <<  1) - 1); */
+
+            }
+            else
+            {
+                // 0 00000000 000111110100000000 010 01
+                // | |        |                  |   |
+                // | |        |                  |   wFormatTag
+                // | |        |                  nChannels
+                // | |        nSamplesPerSec
+                // | wBlockAlign
+                // wBitsPerSample
+
+                codec = (MiniFormatTag)((format) & ((1 << 2) - 1));
+                channels = (format >> (2)) & ((1 << 3) - 1);
+                rate = (format >> (2 + 3)) & ((1 << 18) - 1);
+                alignment = (format >> (2 + 3 + 18)) & ((1 << 8) - 1);
+                //bits = (info.Format >> (2 + 3 + 18 + 8)) & ((1 << 1) - 1);
+            }            
+        }
+
+        /// <param name="audioEngine">Instance of the AudioEngine to associate this wave bank with.</param>
+        /// <param name="streamingWaveBankFilename">Path to the .xwb to stream from.</param>
+        /// <param name="offset">DVD sector-aligned offset within the wave bank data file.</param>
+        /// <param name="packetsize">Stream packet size, in sectors, to use for each stream. The minimum value is 2.</param>
+        /// <remarks>
+        /// <para>This constructor streams wave data as needed.</para>
+        /// <para>Note that packetsize is in sectors, which is 2048 bytes.</para>
+        /// <para>AudioEngine.Update() must be called at least once before using data from a streaming wave bank.</para>
+        /// </remarks>
+        public WaveBank(AudioEngine audioEngine, string streamingWaveBankFilename, int offset, short packetsize)
+            : this(audioEngine, streamingWaveBankFilename, true, offset, packetsize)
+        {
+        }
+
+        internal SoundEffectInstance GetSoundEffectInstance(int trackIndex, out bool streaming)
+        {
+            if (_streaming)
+            {
+                streaming = true;
+                var stream = _streams[trackIndex];
+                return PlatformCreateStream(stream);
+            }
+            else
+            {
+                streaming = false;
+                var sound = _sounds[trackIndex];
+                return sound.GetPooledInstance(true);
+            }
+        }
+
+        /// <summary>
+        /// This event is triggered when the WaveBank is disposed.
+        /// </summary>
+        public event EventHandler<EventArgs> Disposing;
+
+        /// <summary>
+        /// Is true if the WaveBank has been disposed.
+        /// </summary>
+        public bool IsDisposed { get; private set; }
+
+        /// <summary>
+        /// Disposes the WaveBank.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        ~WaveBank()
+        {
+            Dispose(false);
+        }
+
+        private void Dispose(bool disposing)
+        {
+            if (IsDisposed)
+                return;
+
+            IsDisposed = true;
+
+            if (disposing)
+            {
+                foreach (var s in _sounds)
+                    s.Dispose();
+
+                IsPrepared = false;
+                IsInUse = false;
+                EventHelpers.Raise(this, Disposing, EventArgs.Empty);
+            }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/Xact/XactClip.cs b/MonoGame.Framework/Audio/Xact/XactClip.cs
new file mode 100644
index 00000000000..fb8ffe5fbcb
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/XactClip.cs
@@ -0,0 +1,495 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    class XactClip
+    {
+        private readonly float _defaultVolume;
+        private float _volumeScale;
+        private float _volume;
+
+        private readonly ClipEvent[] _events;
+        private float _time;
+        private int _nextEvent;
+
+        internal readonly bool FilterEnabled;
+        internal readonly FilterMode FilterMode;
+        internal readonly float FilterQ;
+        internal readonly ushort FilterFrequency;
+
+        internal readonly bool UseReverb;
+
+        public XactClip (SoundBank soundBank, BinaryReader clipReader, bool useReverb)
+        {
+#pragma warning disable 0219
+            State = SoundState.Stopped;
+
+            UseReverb = useReverb;
+
+            var volumeDb = XactHelpers.ParseDecibels(clipReader.ReadByte());
+            _defaultVolume = XactHelpers.ParseVolumeFromDecibels(volumeDb);
+            var clipOffset = clipReader.ReadUInt32();
+
+            // Read the filter info.
+            var filterQAndFlags = clipReader.ReadUInt16();
+            FilterEnabled = (filterQAndFlags & 1) == 1;
+            FilterMode = (FilterMode)((filterQAndFlags >> 1) & 3);
+            FilterQ = (filterQAndFlags >> 3) * 0.01f;
+            FilterFrequency = clipReader.ReadUInt16();
+
+            var oldPosition = clipReader.BaseStream.Position;
+            clipReader.BaseStream.Seek(clipOffset, SeekOrigin.Begin);
+            
+            var numEvents = clipReader.ReadByte();
+            _events = new ClipEvent[numEvents];
+            
+            for (var i=0; i<numEvents; i++) 
+            {
+                var eventInfo = clipReader.ReadUInt32();
+                var randomOffset = clipReader.ReadUInt16() * 0.001f;
+
+                // TODO: eventInfo still has 11 bits that are unknown!
+                var eventId = eventInfo & 0x1F;
+                var timeStamp = ((eventInfo >> 5) & 0xFFFF) * 0.001f;
+                var unknown = eventInfo >> 21;
+
+                switch (eventId) {
+                case 0:
+                    // Stop Event
+                    throw new NotImplementedException("Stop event");
+
+                case 1:
+                {
+                    // Unknown!
+                    clipReader.ReadByte();
+
+                    // Event flags
+                    var eventFlags = clipReader.ReadByte();
+                    var playRelease = (eventFlags & 0x01) == 0x01;
+                    var panEnabled = (eventFlags & 0x02) == 0x02;
+                    var useCenterSpeaker = (eventFlags & 0x04) == 0x04;
+
+                    int trackIndex = clipReader.ReadUInt16();
+                    int waveBankIndex = clipReader.ReadByte();					
+                    var loopCount = clipReader.ReadByte();
+                    var panAngle = clipReader.ReadUInt16() / 100.0f;
+                    var panArc = clipReader.ReadUInt16() / 100.0f;
+                    
+                    _events[i] = new PlayWaveEvent(
+                        this,
+                        timeStamp, 
+                        randomOffset,
+                        soundBank, 
+                        new[] { waveBankIndex }, 
+                        new[] { trackIndex },
+                        null,
+                        0,
+                        VariationType.Ordered, 
+                        null,
+                        null,
+                        null,
+                        loopCount,
+                        false);
+
+                    break;
+                }
+
+                case 3:
+                {
+                    // Unknown!
+                    clipReader.ReadByte();
+
+                    // Event flags
+                    var eventFlags = clipReader.ReadByte();
+                    var playRelease = (eventFlags & 0x01) == 0x01;
+                    var panEnabled = (eventFlags & 0x02) == 0x02;
+                    var useCenterSpeaker = (eventFlags & 0x04) == 0x04;
+
+                    var loopCount = clipReader.ReadByte();
+                    var panAngle = clipReader.ReadUInt16() / 100.0f;
+                    var panArc = clipReader.ReadUInt16() / 100.0f;
+
+                    // The number of tracks for the variations.
+                    var numTracks = clipReader.ReadUInt16();
+
+                    // Not sure what most of this is.
+                    var moreFlags = clipReader.ReadByte();
+                    var newWaveOnLoop = (moreFlags & 0x40) == 0x40;
+                    
+                    // The variation playlist type seems to be 
+                    // stored in the bottom 4bits only.
+                    var variationType = (VariationType)(moreFlags & 0x0F);
+
+                    // Unknown!
+                    clipReader.ReadBytes(5);
+
+                    // Read in the variation playlist.
+                    var waveBanks = new int[numTracks];
+                    var tracks = new int[numTracks];
+                    var weights = new byte[numTracks];
+                    var totalWeights = 0;
+                    for (var j = 0; j < numTracks; j++)
+                    {
+                        tracks[j] = clipReader.ReadUInt16();
+                        waveBanks[j] = clipReader.ReadByte();
+                        var minWeight = clipReader.ReadByte();
+                        var maxWeight = clipReader.ReadByte();
+                        weights[j] = (byte)(maxWeight - minWeight);
+                        totalWeights += weights[j];
+                    }
+
+                    _events[i] = new PlayWaveEvent(
+                        this,
+                        timeStamp,
+                        randomOffset,
+                        soundBank, 
+                        waveBanks, 
+                        tracks,
+                        weights,
+                        totalWeights,
+                        variationType,
+                        null,
+                        null,
+                        null,
+                        loopCount,
+                        newWaveOnLoop);
+
+                    break;
+                }
+
+                case 4:
+                {
+                    // Unknown!
+                    clipReader.ReadByte();
+
+                    // Event flags
+                    var eventFlags = clipReader.ReadByte();
+                    var playRelease = (eventFlags & 0x01) == 0x01;
+                    var panEnabled = (eventFlags & 0x02) == 0x02;
+                    var useCenterSpeaker = (eventFlags & 0x04) == 0x04;
+
+                    int trackIndex = clipReader.ReadUInt16();
+                    int waveBankIndex = clipReader.ReadByte();
+                    var loopCount = clipReader.ReadByte();
+                    var panAngle = clipReader.ReadUInt16() / 100.0f;
+                    var panArc = clipReader.ReadUInt16() / 100.0f;
+
+                    // Pitch variation range
+                    var minPitch = clipReader.ReadInt16() / 1000.0f;
+                    var maxPitch = clipReader.ReadInt16() / 1000.0f;
+
+                    // Volume variation range
+                    var minVolume = XactHelpers.ParseVolumeFromDecibels(clipReader.ReadByte());
+                    var maxVolume = XactHelpers.ParseVolumeFromDecibels(clipReader.ReadByte());
+
+                    // Filter variation
+                    var minFrequency = clipReader.ReadSingle();
+                    var maxFrequency = clipReader.ReadSingle();
+                    var minQ = clipReader.ReadSingle();
+                    var maxQ = clipReader.ReadSingle();
+
+                    // Unknown!
+                    clipReader.ReadByte();
+
+                    var variationFlags = clipReader.ReadByte();
+
+                    // Enable pitch variation
+                    Vector2? pitchVar = null;
+                    if ((variationFlags & 0x10) == 0x10)
+                        pitchVar = new Vector2(minPitch, maxPitch - minPitch);
+
+                    // Enable volume variation
+                    Vector2? volumeVar = null;
+                    if ((variationFlags & 0x20) == 0x20)
+                        volumeVar = new Vector2(minVolume, maxVolume - minVolume);
+
+                    // Enable filter variation
+                    Vector4? filterVar = null;
+                    if ((variationFlags & 0x40) == 0x40)
+                        filterVar = new Vector4(minFrequency, maxFrequency - minFrequency, minQ, maxQ - minQ);
+
+                    _events[i] = new PlayWaveEvent(
+                        this,
+                        timeStamp,
+                        randomOffset,
+                        soundBank,
+                        new[] { waveBankIndex },
+                        new[] { trackIndex }, 
+                        null,
+                        0,
+                        VariationType.Ordered,
+                        volumeVar,
+                        pitchVar, 
+                        filterVar,
+                        loopCount,
+                        false);
+
+                    break;
+                }
+
+                case 6:
+                {
+                    // Unknown!
+                    clipReader.ReadByte();
+
+                    // Event flags
+                    var eventFlags = clipReader.ReadByte();
+                    var playRelease = (eventFlags & 0x01) == 0x01;
+                    var panEnabled = (eventFlags & 0x02) == 0x02;
+                    var useCenterSpeaker = (eventFlags & 0x04) == 0x04;
+
+                    var loopCount = clipReader.ReadByte();
+                    var panAngle = clipReader.ReadUInt16() / 100.0f;
+                    var panArc = clipReader.ReadUInt16() / 100.0f;
+
+                    // Pitch variation range
+                    var minPitch = clipReader.ReadInt16() / 1000.0f;
+                    var maxPitch = clipReader.ReadInt16() / 1000.0f;
+
+                    // Volume variation range
+                    var minVolume = XactHelpers.ParseVolumeFromDecibels(clipReader.ReadByte());
+                    var maxVolume = XactHelpers.ParseVolumeFromDecibels(clipReader.ReadByte());
+
+                    // Filter variation range
+                    var minFrequency = clipReader.ReadSingle();
+                    var maxFrequency = clipReader.ReadSingle();
+                    var minQ = clipReader.ReadSingle();
+                    var maxQ = clipReader.ReadSingle();
+
+                    // Unknown!
+                    clipReader.ReadByte();
+
+                    // TODO: Still has unknown bits!
+                    var variationFlags = clipReader.ReadByte();
+
+                    // Enable pitch variation
+                    Vector2? pitchVar = null;
+                    if ((variationFlags & 0x10) == 0x10)
+                        pitchVar = new Vector2(minPitch, maxPitch - minPitch);
+
+                    // Enable volume variation
+                    Vector2? volumeVar = null;
+                    if ((variationFlags & 0x20) == 0x20)
+                        volumeVar = new Vector2(minVolume, maxVolume - minVolume);
+
+                    // Enable filter variation
+                    Vector4? filterVar = null;
+                    if ((variationFlags & 0x40) == 0x40)
+                        filterVar = new Vector4(minFrequency, maxFrequency - minFrequency, minQ, maxQ - minQ);
+
+                    // The number of tracks for the variations.
+                    var numTracks = clipReader.ReadUInt16();
+
+                    // Not sure what most of this is.
+                    var moreFlags = clipReader.ReadByte();
+                    var newWaveOnLoop = (moreFlags & 0x40) == 0x40;
+
+                    // The variation playlist type seems to be 
+                    // stored in the bottom 4bits only.
+                    var variationType = (VariationType)(moreFlags & 0x0F);
+
+                    // Unknown!
+                    clipReader.ReadBytes(5);
+
+                    // Read in the variation playlist.
+                    var waveBanks = new int[numTracks];
+                    var tracks = new int[numTracks];
+                    var weights = new byte[numTracks];
+                    var totalWeights = 0;
+                    for (var j = 0; j < numTracks; j++)
+                    {
+                        tracks[j] = clipReader.ReadUInt16();
+                        waveBanks[j] = clipReader.ReadByte();
+                        var minWeight = clipReader.ReadByte();
+                        var maxWeight = clipReader.ReadByte();
+                        weights[j] = (byte)(maxWeight - minWeight);
+                        totalWeights += weights[j];
+                    }
+
+                    _events[i] = new PlayWaveEvent(
+                        this,
+                        timeStamp,
+                        randomOffset,
+                        soundBank,
+                        waveBanks,
+                        tracks,
+                        weights,
+                        totalWeights,
+                        variationType,
+                        volumeVar,
+                        pitchVar, 
+                        filterVar,
+                        loopCount,
+                        newWaveOnLoop);
+
+                    break;
+                }
+
+                case 7:
+                    // Pitch Event
+                    throw new NotImplementedException("Pitch event");
+
+                case 8:
+                {
+                    // Unknown!
+                    clipReader.ReadBytes(2);
+
+                    // Event flags
+                    var eventFlags = clipReader.ReadByte();
+                    var isAdd = (eventFlags & 0x01) == 0x01;
+
+                    // The replacement or additive volume.
+                    var decibles = clipReader.ReadSingle() / 100.0f;
+                    var volume = XactHelpers.ParseVolumeFromDecibels(decibles + (isAdd ? volumeDb : 0));
+
+                    // Unknown!
+                    clipReader.ReadBytes(9);
+
+                    _events[i] = new VolumeEvent(   this, 
+                                                    timeStamp, 
+                                                    randomOffset, 
+                                                    volume);
+                    break;
+                }
+
+                case 17:
+                    // Volume Repeat Event
+                    throw new NotImplementedException("Volume repeat event");
+
+                case 9:
+                    // Marker Event
+                    throw new NotImplementedException("Marker event");
+
+                default:
+                    throw new NotSupportedException("Unknown event " + eventId);
+                }
+            }
+            
+            clipReader.BaseStream.Seek (oldPosition, SeekOrigin.Begin);
+#pragma warning restore 0219
+        }
+
+        internal void Update(float dt)
+        {
+            if (State != SoundState.Playing)
+                return;
+
+            _time += dt;
+
+            // Play the next event.
+            while (_nextEvent < _events.Length)
+            {
+                var evt = _events[_nextEvent];
+                if (_time < evt.TimeStamp)
+                    break;
+
+                evt.Play();
+                ++_nextEvent;
+            }
+
+            // Update all the active events.
+            var isPlaying = _nextEvent < _events.Length;
+            for (var i = 0; i < _nextEvent; i++)
+            {
+                var evt = _events[i];
+                isPlaying |= evt.Update(dt);
+            }
+
+            // Update the state.
+            if (!isPlaying)
+                State = SoundState.Stopped;
+        }
+
+        internal void SetFade(float fadeInDuration, float fadeOutDuration)
+        {
+            foreach (var evt in _events)
+            {
+                if (evt is PlayWaveEvent)
+                    evt.SetFade(fadeInDuration, fadeOutDuration);
+            }
+        }
+        
+        internal void UpdateState(float volume, float pitch, float reverbMix, float? filterFrequency, float? filterQFactor)
+        {
+            _volumeScale = volume;
+            var trackVolume = _volume * _volumeScale;
+
+            foreach (var evt in _events)
+                evt.SetState(trackVolume, pitch, reverbMix, filterFrequency, filterQFactor);
+        }
+
+        public void Play()
+        {
+            _time = 0.0f;
+            _nextEvent = 0;
+            SetVolume(_defaultVolume);
+            State = SoundState.Playing; 
+            Update(0);
+        }
+
+        public void Resume()
+        {
+            foreach (var evt in _events)
+                evt.Resume();
+
+            State = SoundState.Playing;
+        }
+        
+        public void Stop()
+        {
+            foreach (var evt in _events)
+                evt.Stop();
+
+            State = SoundState.Stopped;
+        }
+        
+        public void Pause()
+        {
+            foreach (var evt in _events)
+                evt.Pause();
+
+            State = SoundState.Paused;
+        }
+
+        public SoundState State { get; private set; }
+
+        /// <summary>
+        /// Set the combined volume scale from the parent objects.
+        /// </summary>
+        /// <param name="volume">The volume scale.</param>
+        public void SetVolumeScale(float volume)
+        {
+            _volumeScale = volume;
+            UpdateVolumes();
+        }
+
+        /// <summary>
+        /// Set the volume for the clip.
+        /// </summary>
+        /// <param name="volume">The volume level.</param>
+        public void SetVolume(float volume)
+        {
+            _volume = volume;
+            UpdateVolumes();
+        }
+
+        private void UpdateVolumes()
+        {
+            var volume = _volume * _volumeScale;
+            foreach (var evt in _events)
+                evt.SetTrackVolume(volume);
+        }
+
+        public void SetPan(float pan)
+        {
+            foreach (var evt in _events)
+                evt.SetTrackPan(pan);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Audio/Xact/XactHelpers.cs b/MonoGame.Framework/Audio/Xact/XactHelpers.cs
new file mode 100644
index 00000000000..0ce35af0b21
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/XactHelpers.cs
@@ -0,0 +1,60 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+	static class XactHelpers
+	{
+        static internal readonly Random Random = new Random();
+
+        public static float ParseDecibels(byte decibles)
+        {
+            //lazy 4-param fitting:
+            //0xff 6.0
+            //0xca 2.0
+            //0xbf 1.0
+            //0xb4 0.0
+            //0x8f -4.0
+            //0x5a -12.0
+            //0x14 -38.0
+            //0x00 -96.0
+            const double a = -96.0;
+            const double b = 0.432254984608615;
+            const double c = 80.1748600297963;
+            const double d = 67.7385212334047;
+            var dB = (float)(((a - d) / (1 + (Math.Pow(decibles / c, b)))) + d);
+
+            return dB;
+        }
+
+        public static float ParseVolumeFromDecibels(byte decibles)
+        {
+            //lazy 4-param fitting:
+            //0xff 6.0
+            //0xca 2.0
+            //0xbf 1.0
+            //0xb4 0.0
+            //0x8f -4.0
+            //0x5a -12.0
+            //0x14 -38.0
+            //0x00 -96.0
+            const double a = -96.0;
+            const double b = 0.432254984608615;
+            const double c = 80.1748600297963;
+            const double d = 67.7385212334047;
+            var dB = (float)(((a - d) / (1 + (Math.Pow(decibles / c, b)))) + d);
+
+            return ParseVolumeFromDecibels(dB);
+        }
+
+        public static float ParseVolumeFromDecibels(float decibles)
+        {
+            // Convert from decibles to linear volume.
+            return (float)Math.Pow(10.0, decibles / 20.0);
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Audio/Xact/XactSound.cs b/MonoGame.Framework/Audio/Xact/XactSound.cs
new file mode 100644
index 00000000000..e461f47da22
--- /dev/null
+++ b/MonoGame.Framework/Audio/Xact/XactSound.cs
@@ -0,0 +1,392 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    class XactSound
+    {
+        private readonly bool _complexSound;
+        private readonly XactClip[] _soundClips;
+        private readonly int _waveBankIndex;
+        private readonly int _trackIndex;
+        private readonly float _volume;
+        private readonly float _pitch;
+        private readonly uint _categoryID;
+        private readonly SoundBank _soundBank;
+        private readonly bool _useReverb;
+
+        private SoundEffectInstance _wave;
+        private bool _streaming;
+
+        private float _cueVolume = 1;
+        private float _cuePitch = 0;
+        private float _cueReverbMix = 0;
+        private float? _cueFilterFrequency;
+        private float? _cueFilterQFactor;
+
+        internal readonly int[] RpcCurves;
+        
+        public XactSound(SoundBank soundBank, int waveBankIndex, int trackIndex)
+        {
+            _complexSound = false;
+
+            _soundBank = soundBank;
+            _waveBankIndex = waveBankIndex;
+            _trackIndex = trackIndex;
+            RpcCurves = new int[0];
+        }
+
+        public XactSound(AudioEngine engine, SoundBank soundBank, BinaryReader soundReader)
+        {
+            _soundBank = soundBank;
+            
+            var flags = soundReader.ReadByte();
+            _complexSound = (flags & 0x1) != 0;
+            var hasRPCs = (flags & 0x0E) != 0;
+            var hasDSPs = (flags & 0x10) != 0;
+
+            _categoryID = soundReader.ReadUInt16();
+            _volume = XactHelpers.ParseVolumeFromDecibels(soundReader.ReadByte());
+            _pitch = soundReader.ReadInt16() / 1000.0f;
+            soundReader.ReadByte(); //priority
+            soundReader.ReadUInt16(); // filter stuff?
+            
+            var numClips = 0;
+            if (_complexSound)
+                numClips = soundReader.ReadByte();
+            else 
+            {
+                _trackIndex = soundReader.ReadUInt16();
+                _waveBankIndex = soundReader.ReadByte();
+            }
+
+            if (!hasRPCs)
+                RpcCurves = new int[0];
+            else
+            {
+                var current = soundReader.BaseStream.Position;
+
+                // This doesn't seem to be used... might have been there
+                // to allow for some future file format expansion.
+                var dataLength = soundReader.ReadUInt16();
+
+                var numPresets = soundReader.ReadByte();
+                RpcCurves = new int[numPresets];
+                for (var i = 0; i < numPresets; i++)
+                    RpcCurves[i] = engine.GetRpcIndex(soundReader.ReadUInt32());
+
+                // Just in case seek to the right spot.
+                soundReader.BaseStream.Seek(current + dataLength, SeekOrigin.Begin);
+            }
+
+            if (!hasDSPs)
+                _useReverb = false;
+            else
+            {
+                // The file format for this seems to follow the pattern for 
+                // the RPC curves above, but in this case XACT only supports
+                // a single effect...  Microsoft Reverb... so just set it.
+                _useReverb = true;
+                soundReader.BaseStream.Seek(7, SeekOrigin.Current);
+            }
+
+            if (_complexSound)
+            {
+                _soundClips = new XactClip[numClips];
+                for (int i = 0; i < numClips; i++)
+                    _soundClips[i] = new XactClip(soundBank, soundReader, _useReverb);
+            }
+
+            var category = engine.Categories[_categoryID];
+            category.AddSound(this);
+        }
+
+        internal void SetFade(float fadeInTime, float fadeOutTime)
+        {
+            if (fadeInTime == 0.0f &&
+                fadeOutTime == 0.0f )
+                return;
+
+            if (_complexSound)
+            {
+                foreach (var sound in _soundClips)
+                    sound.SetFade(fadeInTime, fadeOutTime);
+            }
+            else
+            {
+                // TODO:
+            }
+        }
+
+        public void Play(float volume, AudioEngine engine)
+        {
+            _cueVolume = volume;
+            var category = engine.Categories[_categoryID];
+
+            var curInstances = category.GetPlayingInstanceCount();
+            if (curInstances >= category.maxInstances)
+            {
+                var prevSound = category.GetOldestInstance();
+
+                if (prevSound != null)
+                {
+                    prevSound.SetFade(0.0f, category.fadeOut);
+                    prevSound.Stop(AudioStopOptions.Immediate);
+                    SetFade(category.fadeIn, 0.0f);
+                }
+            }
+
+            float finalVolume = _volume * _cueVolume * category._volume[0];
+            float finalPitch = _pitch + _cuePitch;
+            float finalMix = _useReverb ? _cueReverbMix : 0.0f;
+
+            if (_complexSound) 
+            {
+                foreach (XactClip clip in _soundClips)
+                {
+                    clip.UpdateState(finalVolume, finalPitch, finalMix, _cueFilterFrequency, _cueFilterQFactor);
+                    clip.Play();
+                }
+            } 
+            else 
+            {
+                if (_wave != null)
+                {
+                    if (_streaming)
+                        _wave.Dispose();
+					else
+						_wave._isXAct = false;					
+                    _wave = null;
+                }
+
+                    _wave = _soundBank.GetSoundEffectInstance(_waveBankIndex, _trackIndex, out _streaming);
+
+                if (_wave == null)
+                {
+                    // We couldn't create a sound effect instance, most likely
+                    // because we've reached the sound pool limits.
+                    return;
+                }
+
+                _wave.Pitch = finalPitch;
+                _wave.Volume = finalVolume;
+                _wave.PlatformSetReverbMix(finalMix);
+                _wave.Play();
+            }
+        }
+
+        internal void Update(float dt)
+        {
+            if (_complexSound)
+            {
+                foreach (var sound in _soundClips)
+                    sound.Update(dt);
+            }
+            else
+            {
+                if (_wave != null && _wave.State == SoundState.Stopped)
+                {
+                    if (_streaming)
+                        _wave.Dispose();
+					else
+						_wave._isXAct = false;					
+                    _wave = null;
+                }
+            }
+        }
+
+        internal void StopAll(AudioStopOptions options)
+        {
+            if (_complexSound)
+            {
+                foreach (XactClip clip in _soundClips)
+                    clip.Stop();
+            }
+            else
+            {
+                if (_wave != null)
+                {
+                    _wave.Stop();
+                    if (_streaming)
+                        _wave.Dispose();
+ 					else
+						_wave._isXAct = false;					
+                   _wave = null;
+                }
+            }
+        }
+        
+        public void Stop(AudioStopOptions options)
+        {
+            if (_complexSound)
+            {
+                foreach (var sound in _soundClips)
+                    sound.Stop();
+            }
+            else
+            {
+                if (_wave != null)
+                {
+                    _wave.Stop();
+                    if (_streaming)
+                        _wave.Dispose();
+					else
+						_wave._isXAct = false;					
+                    _wave = null;
+                }
+            }
+        }
+        
+        public void Pause()
+        {
+            if (_complexSound)
+            {
+                foreach (var sound in _soundClips)
+                {
+                    if (sound.State == SoundState.Playing)
+                        sound.Pause();
+                }
+            }
+            else
+            {
+                if (_wave != null && _wave.State == SoundState.Playing)
+                    _wave.Pause();
+            }
+        }
+                
+        public void Resume()
+        {
+            if (_complexSound)
+            {
+                foreach (var sound in _soundClips)
+                {
+                    if (sound.State == SoundState.Paused)
+                        sound.Resume();
+                }
+            }
+            else
+            {
+                if (_wave != null && _wave.State == SoundState.Paused)
+                    _wave.Resume();
+            }
+        }
+
+        internal void UpdateCategoryVolume(float categoryVolume)
+        {
+            // The different volumes modulate each other.
+            var volume = _volume * _cueVolume * categoryVolume;
+
+            if (_complexSound)
+            {
+                foreach (var clip in _soundClips)
+                    clip.SetVolumeScale(volume);
+            }
+            else
+            {
+                if (_wave != null)
+                    _wave.Volume = volume;
+            }
+        }
+
+        internal void UpdateState(AudioEngine engine, float volume, float pitch, float reverbMix, float? filterFrequency, float? filterQFactor)
+        {
+            _cueVolume = volume;
+            var finalVolume = _volume * _cueVolume * engine.Categories[_categoryID]._volume[0];
+
+            _cueReverbMix = reverbMix;
+            _cueFilterFrequency = filterFrequency;
+            _cueFilterQFactor = filterQFactor;
+
+            _cuePitch = pitch;
+            var finalPitch = _pitch + _cuePitch;
+
+            if (_complexSound)
+            {
+                foreach (var clip in _soundClips)
+                    clip.UpdateState(finalVolume, finalPitch, _useReverb ? _cueReverbMix : 0.0f, _cueFilterFrequency, _cueFilterQFactor);
+            }
+            else if (_wave != null)
+            {
+                _wave.PlatformSetReverbMix(_useReverb ? _cueReverbMix : 0.0f);
+                _wave.Pitch = finalPitch;
+                _wave.Volume = finalVolume;
+            }
+        }
+
+        internal void SetCuePan(float pan)
+        {
+            if (_complexSound)
+            {
+                foreach (var clip in _soundClips)
+                    clip.SetPan(pan);
+            }
+            else
+            {
+                if (_wave != null)
+                    _wave.Pan = pan;
+            }
+        }
+
+        public bool Playing 
+        {
+            get 
+            {
+                if (_complexSound)
+                {
+                    foreach (var clip in _soundClips)
+                        if (clip.State == SoundState.Playing)
+                            return true;
+
+                    return false;
+                } 
+
+                return _wave != null && _wave.State == SoundState.Playing;
+            }
+        }
+
+        public bool Stopped
+        {
+            get
+            {
+                if (_complexSound)
+                {
+                    var notStopped = false;
+
+                    // All clips must be stopped for the sound to be stopped.
+                    foreach (var clip in _soundClips)
+                    {
+                        if (clip.State != SoundState.Stopped)
+                            notStopped = true;
+                    }
+
+                    return !notStopped;
+                }
+
+                // We null the wave when it it stopped.
+                return _wave == null;
+            }
+        }
+
+        public bool IsPaused
+        {
+            get
+            {
+                if (_complexSound) 
+                {
+                    foreach (var clip in _soundClips)
+                        if (clip.State == SoundState.Paused) 
+                            return true;
+
+                    return false;
+                }
+
+                return _wave != null && _wave.State == SoundState.Paused;
+            }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/BoundingBox.cs b/MonoGame.Framework/BoundingBox.cs
new file mode 100644
index 00000000000..8e79fb8a04e
--- /dev/null
+++ b/MonoGame.Framework/BoundingBox.cs
@@ -0,0 +1,538 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework
+{
+    [DataContract]
+    [DebuggerDisplay("{DebugDisplayString,nq}")]
+    public struct BoundingBox : IEquatable<BoundingBox>
+    {
+
+        #region Public Fields
+
+        [DataMember]
+        public Vector3 Min;
+      
+        [DataMember]
+        public Vector3 Max;
+
+        public const int CornerCount = 8;
+
+        #endregion Public Fields
+
+
+        #region Public Constructors
+
+        public BoundingBox(Vector3 min, Vector3 max)
+        {
+            this.Min = min;
+            this.Max = max;
+        }
+
+        #endregion Public Constructors
+
+
+        #region Public Methods
+
+        public ContainmentType Contains(BoundingBox box)
+        {
+            //test if all corner is in the same side of a face by just checking min and max
+            if (box.Max.X < Min.X
+                || box.Min.X > Max.X
+                || box.Max.Y < Min.Y
+                || box.Min.Y > Max.Y
+                || box.Max.Z < Min.Z
+                || box.Min.Z > Max.Z)
+                return ContainmentType.Disjoint;
+
+
+            if (box.Min.X >= Min.X
+                && box.Max.X <= Max.X
+                && box.Min.Y >= Min.Y
+                && box.Max.Y <= Max.Y
+                && box.Min.Z >= Min.Z
+                && box.Max.Z <= Max.Z)
+                return ContainmentType.Contains;
+
+            return ContainmentType.Intersects;
+        }
+
+        public void Contains(ref BoundingBox box, out ContainmentType result)
+        {
+            result = Contains(box);
+        }
+
+        public ContainmentType Contains(BoundingFrustum frustum)
+        {
+            //TODO: bad done here need a fix. 
+            //Because question is not frustum contain box but reverse and this is not the same
+            int i;
+            ContainmentType contained;
+            Vector3[] corners = frustum.GetCorners();
+
+            // First we check if frustum is in box
+            for (i = 0; i < corners.Length; i++)
+            {
+                this.Contains(ref corners[i], out contained);
+                if (contained == ContainmentType.Disjoint)
+                    break;
+            }
+
+            if (i == corners.Length) // This means we checked all the corners and they were all contain or instersect
+                return ContainmentType.Contains;
+
+            if (i != 0)             // if i is not equal to zero, we can fastpath and say that this box intersects
+                return ContainmentType.Intersects;
+
+
+            // If we get here, it means the first (and only) point we checked was actually contained in the frustum.
+            // So we assume that all other points will also be contained. If one of the points is disjoint, we can
+            // exit immediately saying that the result is Intersects
+            i++;
+            for (; i < corners.Length; i++)
+            {
+                this.Contains(ref corners[i], out contained);
+                if (contained != ContainmentType.Contains)
+                    return ContainmentType.Intersects;
+
+            }
+
+            // If we get here, then we know all the points were actually contained, therefore result is Contains
+            return ContainmentType.Contains;
+        }
+
+        public ContainmentType Contains(BoundingSphere sphere)
+        {
+            if (sphere.Center.X - Min.X >= sphere.Radius
+                && sphere.Center.Y - Min.Y >= sphere.Radius
+                && sphere.Center.Z - Min.Z >= sphere.Radius
+                && Max.X - sphere.Center.X >= sphere.Radius
+                && Max.Y - sphere.Center.Y >= sphere.Radius
+                && Max.Z - sphere.Center.Z >= sphere.Radius)
+                return ContainmentType.Contains;
+
+            double dmin = 0;
+
+            double e = sphere.Center.X - Min.X;
+            if (e < 0)
+            {
+                if (e < -sphere.Radius)
+                {
+                    return ContainmentType.Disjoint;
+                }
+                dmin += e * e;
+            }
+            else
+            {
+                e = sphere.Center.X - Max.X;
+                if (e > 0)
+                {
+                    if (e > sphere.Radius)
+                    {
+                        return ContainmentType.Disjoint;
+                    }
+                    dmin += e * e;
+                }
+            }
+
+            e = sphere.Center.Y - Min.Y;
+            if (e < 0)
+            {
+                if (e < -sphere.Radius)
+                {
+                    return ContainmentType.Disjoint;
+                }
+                dmin += e * e;
+            }
+            else
+            {
+                e = sphere.Center.Y - Max.Y;
+                if (e > 0)
+                {
+                    if (e > sphere.Radius)
+                    {
+                        return ContainmentType.Disjoint;
+                    }
+                    dmin += e * e;
+                }
+            }
+
+            e = sphere.Center.Z - Min.Z;
+            if (e < 0)
+            {
+                if (e < -sphere.Radius)
+                {
+                    return ContainmentType.Disjoint;
+                }
+                dmin += e * e;
+            }
+            else
+            {
+                e = sphere.Center.Z - Max.Z;
+                if (e > 0)
+                {
+                    if (e > sphere.Radius)
+                    {
+                        return ContainmentType.Disjoint;
+                    }
+                    dmin += e * e;
+                }
+            }
+
+            if (dmin <= sphere.Radius * sphere.Radius)
+                return ContainmentType.Intersects;
+
+            return ContainmentType.Disjoint;
+        }
+
+        public void Contains(ref BoundingSphere sphere, out ContainmentType result)
+        {
+            result = this.Contains(sphere);
+        }
+
+        public ContainmentType Contains(Vector3 point)
+        {
+            ContainmentType result;
+            this.Contains(ref point, out result);
+            return result;
+        }
+
+        public void Contains(ref Vector3 point, out ContainmentType result)
+        {
+            //first we get if point is out of box
+            if (point.X < this.Min.X
+                || point.X > this.Max.X
+                || point.Y < this.Min.Y
+                || point.Y > this.Max.Y
+                || point.Z < this.Min.Z
+                || point.Z > this.Max.Z)
+            {
+                result = ContainmentType.Disjoint;
+            }
+            else
+            {
+                result = ContainmentType.Contains;
+            }
+        }
+
+        private static readonly Vector3 MaxVector3 = new Vector3(float.MaxValue);
+        private static readonly Vector3 MinVector3 = new Vector3(float.MinValue);
+
+        /// <summary>
+        /// Create a bounding box from the given list of points.
+        /// </summary>
+        /// <param name="points">The list of Vector3 instances defining the point cloud to bound</param>
+        /// <returns>A bounding box that encapsulates the given point cloud.</returns>
+        /// <exception cref="System.ArgumentException">Thrown if the given list has no points.</exception>
+        public static BoundingBox CreateFromPoints(IEnumerable<Vector3> points)
+        {
+            if (points == null)
+                throw new ArgumentNullException();
+
+            var empty = true;
+            var minVec = MaxVector3;
+            var maxVec = MinVector3;
+            foreach (var ptVector in points)
+            {
+                minVec.X = (minVec.X < ptVector.X) ? minVec.X : ptVector.X;
+                minVec.Y = (minVec.Y < ptVector.Y) ? minVec.Y : ptVector.Y;
+                minVec.Z = (minVec.Z < ptVector.Z) ? minVec.Z : ptVector.Z;
+
+                maxVec.X = (maxVec.X > ptVector.X) ? maxVec.X : ptVector.X;
+                maxVec.Y = (maxVec.Y > ptVector.Y) ? maxVec.Y : ptVector.Y;
+                maxVec.Z = (maxVec.Z > ptVector.Z) ? maxVec.Z : ptVector.Z;
+
+                empty = false;
+            }
+            if (empty)
+                throw new ArgumentException();
+
+            return new BoundingBox(minVec, maxVec);
+        }
+
+        public static BoundingBox CreateFromSphere(BoundingSphere sphere)
+        {
+            BoundingBox result;
+            CreateFromSphere(ref sphere, out result);
+            return result;
+        }
+
+        public static void CreateFromSphere(ref BoundingSphere sphere, out BoundingBox result)
+        {
+            var corner = new Vector3(sphere.Radius);
+            result.Min = sphere.Center - corner;
+            result.Max = sphere.Center + corner;
+        }
+
+        public static BoundingBox CreateMerged(BoundingBox original, BoundingBox additional)
+        {
+            BoundingBox result;
+            CreateMerged(ref original, ref additional, out result);
+            return result;
+        }
+
+        public static void CreateMerged(ref BoundingBox original, ref BoundingBox additional, out BoundingBox result)
+        {
+            result.Min.X = Math.Min(original.Min.X, additional.Min.X);
+            result.Min.Y = Math.Min(original.Min.Y, additional.Min.Y);
+            result.Min.Z = Math.Min(original.Min.Z, additional.Min.Z);
+            result.Max.X = Math.Max(original.Max.X, additional.Max.X);
+            result.Max.Y = Math.Max(original.Max.Y, additional.Max.Y);
+            result.Max.Z = Math.Max(original.Max.Z, additional.Max.Z);
+        }
+
+        public bool Equals(BoundingBox other)
+        {
+            return (this.Min == other.Min) && (this.Max == other.Max);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return (obj is BoundingBox) ? this.Equals((BoundingBox)obj) : false;
+        }
+
+        public Vector3[] GetCorners()
+        {
+            return new Vector3[] {
+                new Vector3(this.Min.X, this.Max.Y, this.Max.Z), 
+                new Vector3(this.Max.X, this.Max.Y, this.Max.Z),
+                new Vector3(this.Max.X, this.Min.Y, this.Max.Z), 
+                new Vector3(this.Min.X, this.Min.Y, this.Max.Z), 
+                new Vector3(this.Min.X, this.Max.Y, this.Min.Z),
+                new Vector3(this.Max.X, this.Max.Y, this.Min.Z),
+                new Vector3(this.Max.X, this.Min.Y, this.Min.Z),
+                new Vector3(this.Min.X, this.Min.Y, this.Min.Z)
+            };
+        }
+
+        public void GetCorners(Vector3[] corners)
+        {
+            if (corners == null)
+            {
+                throw new ArgumentNullException("corners");
+            }
+            if (corners.Length < 8)
+            {
+                throw new ArgumentOutOfRangeException("corners", "Not Enought Corners");
+            }
+            corners[0].X = this.Min.X;
+            corners[0].Y = this.Max.Y;
+            corners[0].Z = this.Max.Z;
+            corners[1].X = this.Max.X;
+            corners[1].Y = this.Max.Y;
+            corners[1].Z = this.Max.Z;
+            corners[2].X = this.Max.X;
+            corners[2].Y = this.Min.Y;
+            corners[2].Z = this.Max.Z;
+            corners[3].X = this.Min.X;
+            corners[3].Y = this.Min.Y;
+            corners[3].Z = this.Max.Z;
+            corners[4].X = this.Min.X;
+            corners[4].Y = this.Max.Y;
+            corners[4].Z = this.Min.Z;
+            corners[5].X = this.Max.X;
+            corners[5].Y = this.Max.Y;
+            corners[5].Z = this.Min.Z;
+            corners[6].X = this.Max.X;
+            corners[6].Y = this.Min.Y;
+            corners[6].Z = this.Min.Z;
+            corners[7].X = this.Min.X;
+            corners[7].Y = this.Min.Y;
+            corners[7].Z = this.Min.Z;
+        }
+
+        public override int GetHashCode()
+        {
+            return this.Min.GetHashCode() + this.Max.GetHashCode();
+        }
+
+        public bool Intersects(BoundingBox box)
+        {
+            bool result;
+            Intersects(ref box, out result);
+            return result;
+        }
+
+        public void Intersects(ref BoundingBox box, out bool result)
+        {
+            if ((this.Max.X >= box.Min.X) && (this.Min.X <= box.Max.X))
+            {
+                if ((this.Max.Y < box.Min.Y) || (this.Min.Y > box.Max.Y))
+                {
+                    result = false;
+                    return;
+                }
+
+                result = (this.Max.Z >= box.Min.Z) && (this.Min.Z <= box.Max.Z);
+                return;
+            }
+
+            result = false;
+            return;
+        }
+
+        public bool Intersects(BoundingFrustum frustum)
+        {
+            return frustum.Intersects(this);
+        }
+
+        public bool Intersects(BoundingSphere sphere)
+        {
+            if (sphere.Center.X - Min.X > sphere.Radius
+                && sphere.Center.Y - Min.Y > sphere.Radius
+                && sphere.Center.Z - Min.Z > sphere.Radius
+                && Max.X - sphere.Center.X > sphere.Radius
+                && Max.Y - sphere.Center.Y > sphere.Radius
+                && Max.Z - sphere.Center.Z > sphere.Radius)
+                return true;
+
+            double dmin = 0;
+
+            if (sphere.Center.X - Min.X <= sphere.Radius)
+                dmin += (sphere.Center.X - Min.X) * (sphere.Center.X - Min.X);
+            else if (Max.X - sphere.Center.X <= sphere.Radius)
+                dmin += (sphere.Center.X - Max.X) * (sphere.Center.X - Max.X);
+
+            if (sphere.Center.Y - Min.Y <= sphere.Radius)
+                dmin += (sphere.Center.Y - Min.Y) * (sphere.Center.Y - Min.Y);
+            else if (Max.Y - sphere.Center.Y <= sphere.Radius)
+                dmin += (sphere.Center.Y - Max.Y) * (sphere.Center.Y - Max.Y);
+
+            if (sphere.Center.Z - Min.Z <= sphere.Radius)
+                dmin += (sphere.Center.Z - Min.Z) * (sphere.Center.Z - Min.Z);
+            else if (Max.Z - sphere.Center.Z <= sphere.Radius)
+                dmin += (sphere.Center.Z - Max.Z) * (sphere.Center.Z - Max.Z);
+
+            if (dmin <= sphere.Radius * sphere.Radius)
+                return true;
+
+            return false;
+        }
+
+        public void Intersects(ref BoundingSphere sphere, out bool result)
+        {
+            result = Intersects(sphere);
+        }
+
+        public PlaneIntersectionType Intersects(Plane plane)
+        {
+            PlaneIntersectionType result;
+            Intersects(ref plane, out result);
+            return result;
+        }
+
+        public void Intersects(ref Plane plane, out PlaneIntersectionType result)
+        {
+            // See http://zach.in.tu-clausthal.de/teaching/cg_literatur/lighthouse3d_view_frustum_culling/index.html
+
+            Vector3 positiveVertex;
+            Vector3 negativeVertex;
+
+            if (plane.Normal.X >= 0)
+            {
+                positiveVertex.X = Max.X;
+                negativeVertex.X = Min.X;
+            }
+            else
+            {
+                positiveVertex.X = Min.X;
+                negativeVertex.X = Max.X;
+            }
+
+            if (plane.Normal.Y >= 0)
+            {
+                positiveVertex.Y = Max.Y;
+                negativeVertex.Y = Min.Y;
+            }
+            else
+            {
+                positiveVertex.Y = Min.Y;
+                negativeVertex.Y = Max.Y;
+            }
+
+            if (plane.Normal.Z >= 0)
+            {
+                positiveVertex.Z = Max.Z;
+                negativeVertex.Z = Min.Z;
+            }
+            else
+            {
+                positiveVertex.Z = Min.Z;
+                negativeVertex.Z = Max.Z;
+            }
+
+            // Inline Vector3.Dot(plane.Normal, negativeVertex) + plane.D;
+            var distance = plane.Normal.X * negativeVertex.X + plane.Normal.Y * negativeVertex.Y + plane.Normal.Z * negativeVertex.Z + plane.D;
+            if (distance > 0)
+            {
+                result = PlaneIntersectionType.Front;
+                return;
+            }
+
+            // Inline Vector3.Dot(plane.Normal, positiveVertex) + plane.D;
+            distance = plane.Normal.X * positiveVertex.X + plane.Normal.Y * positiveVertex.Y + plane.Normal.Z * positiveVertex.Z + plane.D;
+            if (distance < 0)
+            {
+                result = PlaneIntersectionType.Back;
+                return;
+            }
+
+            result = PlaneIntersectionType.Intersecting;
+        }
+
+        public Nullable<float> Intersects(Ray ray)
+        {
+            return ray.Intersects(this);
+        }
+
+        public void Intersects(ref Ray ray, out Nullable<float> result)
+        {
+            result = Intersects(ray);
+        }
+
+        public static bool operator ==(BoundingBox a, BoundingBox b)
+        {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(BoundingBox a, BoundingBox b)
+        {
+            return !a.Equals(b);
+        }
+
+        internal string DebugDisplayString
+        {
+            get
+            {
+                return string.Concat(
+                    "Min( ", this.Min.DebugDisplayString, " )  \r\n",
+                    "Max( ",this.Max.DebugDisplayString, " )"
+                    );
+            }
+        }
+
+        public override string ToString()
+        {
+            return "{{Min:" + this.Min.ToString() + " Max:" + this.Max.ToString() + "}}";
+        }
+
+        /// <summary>
+        /// Deconstruction method for <see cref="BoundingBox"/>.
+        /// </summary>
+        /// <param name="min"></param>
+        /// <param name="max"></param>
+        public void Deconstruct(out Vector3 min, out Vector3 max)
+        {
+            min = Min;
+            max = Max;
+        }
+
+        #endregion Public Methods
+    }
+}
diff --git a/MonoGame.Framework/BoundingFrustum.cs b/MonoGame.Framework/BoundingFrustum.cs
new file mode 100644
index 00000000000..b8211661bda
--- /dev/null
+++ b/MonoGame.Framework/BoundingFrustum.cs
@@ -0,0 +1,578 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Defines a viewing frustum for intersection operations.
+    /// </summary>
+    [DebuggerDisplay("{DebugDisplayString,nq}")]
+    public class BoundingFrustum : IEquatable<BoundingFrustum>
+    {
+        #region Private Fields
+
+        private Matrix _matrix;
+        private readonly Vector3[] _corners = new Vector3[CornerCount];
+        private readonly Plane[] _planes = new Plane[PlaneCount];
+
+        #endregion
+
+        #region Public Fields
+
+        /// <summary>
+        /// The number of planes in the frustum.
+        /// </summary>
+        public const int PlaneCount = 6;
+
+        /// <summary>
+        /// The number of corner points in the frustum.
+        /// </summary>
+        public const int CornerCount = 8;
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets or sets the <see cref="Matrix"/> of the frustum.
+        /// </summary>
+        public Matrix Matrix
+        {
+            get { return this._matrix; }
+            set
+            {
+                this._matrix = value;
+                this.CreatePlanes();    // FIXME: The odds are the planes will be used a lot more often than the matrix
+                this.CreateCorners();   // is updated, so this should help performance. I hope ;)
+            }
+        }
+
+        /// <summary>
+        /// Gets the near plane of the frustum.
+        /// </summary>
+        public Plane Near
+        {
+            get { return this._planes[0]; }
+        }
+
+        /// <summary>
+        /// Gets the far plane of the frustum.
+        /// </summary>
+        public Plane Far
+        {
+            get { return this._planes[1]; }
+        }
+
+        /// <summary>
+        /// Gets the left plane of the frustum.
+        /// </summary>
+        public Plane Left
+        {
+            get { return this._planes[2]; }
+        }
+
+        /// <summary>
+        /// Gets the right plane of the frustum.
+        /// </summary>
+        public Plane Right
+        {
+            get { return this._planes[3]; }
+        }
+
+        /// <summary>
+        /// Gets the top plane of the frustum.
+        /// </summary>
+        public Plane Top
+        {
+            get { return this._planes[4]; }
+        }
+
+        /// <summary>
+        /// Gets the bottom plane of the frustum.
+        /// </summary>
+        public Plane Bottom
+        {
+            get { return this._planes[5]; }
+        }
+
+        #endregion
+
+        #region Internal Properties
+
+        internal string DebugDisplayString
+        {
+            get
+            {
+                return string.Concat(
+                    "Near( ", this._planes[0].DebugDisplayString, " )  \r\n",
+                    "Far( ", this._planes[1].DebugDisplayString, " )  \r\n",
+                    "Left( ", this._planes[2].DebugDisplayString, " )  \r\n",
+                    "Right( ", this._planes[3].DebugDisplayString, " )  \r\n",
+                    "Top( ", this._planes[4].DebugDisplayString, " )  \r\n",
+                    "Bottom( ", this._planes[5].DebugDisplayString, " )  "
+                    );
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Constructs the frustum by extracting the view planes from a matrix.
+        /// </summary>
+        /// <param name="value">Combined matrix which usually is (View * Projection).</param>
+        public BoundingFrustum(Matrix value)
+        {
+            this._matrix = value;
+            this.CreatePlanes();
+            this.CreateCorners();
+        }
+
+        #endregion
+
+        #region Operators
+
+        /// <summary>
+        /// Compares whether two <see cref="BoundingFrustum"/> instances are equal.
+        /// </summary>
+        /// <param name="a"><see cref="BoundingFrustum"/> instance on the left of the equal sign.</param>
+        /// <param name="b"><see cref="BoundingFrustum"/> instance on the right of the equal sign.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(BoundingFrustum a, BoundingFrustum b)
+        {
+            if (Equals(a, null))
+                return (Equals(b, null));
+
+            if (Equals(b, null))
+                return (Equals(a, null));
+
+            return a._matrix == (b._matrix);
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="BoundingFrustum"/> instances are not equal.
+        /// </summary>
+        /// <param name="a"><see cref="BoundingFrustum"/> instance on the left of the not equal sign.</param>
+        /// <param name="b"><see cref="BoundingFrustum"/> instance on the right of the not equal sign.</param>
+        /// <returns><c>true</c> if the instances are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(BoundingFrustum a, BoundingFrustum b)
+        {
+            return !(a == b);
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        #region Contains
+
+        /// <summary>
+        /// Containment test between this <see cref="BoundingFrustum"/> and specified <see cref="BoundingBox"/>.
+        /// </summary>
+        /// <param name="box">A <see cref="BoundingBox"/> for testing.</param>
+        /// <returns>Result of testing for containment between this <see cref="BoundingFrustum"/> and specified <see cref="BoundingBox"/>.</returns>
+        public ContainmentType Contains(BoundingBox box)
+        {
+            var result = default(ContainmentType);
+            this.Contains(ref box, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Containment test between this <see cref="BoundingFrustum"/> and specified <see cref="BoundingBox"/>.
+        /// </summary>
+        /// <param name="box">A <see cref="BoundingBox"/> for testing.</param>
+        /// <param name="result">Result of testing for containment between this <see cref="BoundingFrustum"/> and specified <see cref="BoundingBox"/> as an output parameter.</param>
+        public void Contains(ref BoundingBox box, out ContainmentType result)
+        {
+            var intersects = false;
+            for (var i = 0; i < PlaneCount; ++i)
+            {
+                var planeIntersectionType = default(PlaneIntersectionType);
+                box.Intersects(ref this._planes[i], out planeIntersectionType);
+                switch (planeIntersectionType)
+                {
+                case PlaneIntersectionType.Front:
+                    result = ContainmentType.Disjoint; 
+                    return;
+                case PlaneIntersectionType.Intersecting:
+                    intersects = true;
+                    break;
+                }
+            }
+            result = intersects ? ContainmentType.Intersects : ContainmentType.Contains;
+        }
+
+        /// <summary>
+        /// Containment test between this <see cref="BoundingFrustum"/> and specified <see cref="BoundingFrustum"/>.
+        /// </summary>
+        /// <param name="frustum">A <see cref="BoundingFrustum"/> for testing.</param>
+        /// <returns>Result of testing for containment between this <see cref="BoundingFrustum"/> and specified <see cref="BoundingFrustum"/>.</returns>
+        public ContainmentType Contains(BoundingFrustum frustum)
+        {
+            if (this == frustum)                // We check to see if the two frustums are equal
+                return ContainmentType.Contains;// If they are, there's no need to go any further.
+
+            var intersects = false;
+            for (var i = 0; i < PlaneCount; ++i)
+            {
+                PlaneIntersectionType planeIntersectionType;
+                frustum.Intersects(ref _planes[i], out planeIntersectionType);
+                switch (planeIntersectionType)
+                {
+                    case PlaneIntersectionType.Front:
+                        return ContainmentType.Disjoint;
+                    case PlaneIntersectionType.Intersecting:
+                        intersects = true;
+                        break;
+                }
+            }
+            return intersects ? ContainmentType.Intersects : ContainmentType.Contains;
+        }
+
+        /// <summary>
+        /// Containment test between this <see cref="BoundingFrustum"/> and specified <see cref="BoundingSphere"/>.
+        /// </summary>
+        /// <param name="sphere">A <see cref="BoundingSphere"/> for testing.</param>
+        /// <returns>Result of testing for containment between this <see cref="BoundingFrustum"/> and specified <see cref="BoundingSphere"/>.</returns>
+        public ContainmentType Contains(BoundingSphere sphere)
+        {
+            var result = default(ContainmentType);
+            this.Contains(ref sphere, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Containment test between this <see cref="BoundingFrustum"/> and specified <see cref="BoundingSphere"/>.
+        /// </summary>
+        /// <param name="sphere">A <see cref="BoundingSphere"/> for testing.</param>
+        /// <param name="result">Result of testing for containment between this <see cref="BoundingFrustum"/> and specified <see cref="BoundingSphere"/> as an output parameter.</param>
+        public void Contains(ref BoundingSphere sphere, out ContainmentType result)
+        {
+            var intersects = false;
+            for (var i = 0; i < PlaneCount; ++i) 
+            {
+                var planeIntersectionType = default(PlaneIntersectionType);
+
+                // TODO: we might want to inline this for performance reasons
+                sphere.Intersects(ref this._planes[i], out planeIntersectionType);
+                switch (planeIntersectionType)
+                {
+                case PlaneIntersectionType.Front:
+                    result = ContainmentType.Disjoint; 
+                    return;
+                case PlaneIntersectionType.Intersecting:
+                    intersects = true;
+                    break;
+                }
+            }
+            result = intersects ? ContainmentType.Intersects : ContainmentType.Contains;
+        }
+
+        /// <summary>
+        /// Containment test between this <see cref="BoundingFrustum"/> and specified <see cref="Vector3"/>.
+        /// </summary>
+        /// <param name="point">A <see cref="Vector3"/> for testing.</param>
+        /// <returns>Result of testing for containment between this <see cref="BoundingFrustum"/> and specified <see cref="Vector3"/>.</returns>
+        public ContainmentType Contains(Vector3 point)
+        {
+            var result = default(ContainmentType);
+            this.Contains(ref point, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Containment test between this <see cref="BoundingFrustum"/> and specified <see cref="Vector3"/>.
+        /// </summary>
+        /// <param name="point">A <see cref="Vector3"/> for testing.</param>
+        /// <param name="result">Result of testing for containment between this <see cref="BoundingFrustum"/> and specified <see cref="Vector3"/> as an output parameter.</param>
+        public void Contains(ref Vector3 point, out ContainmentType result)
+        {
+            for (var i = 0; i < PlaneCount; ++i)
+            {
+                // TODO: we might want to inline this for performance reasons
+                if (PlaneHelper.ClassifyPoint(ref point, ref this._planes[i]) > 0)
+                {   
+                    result = ContainmentType.Disjoint;
+                    return;
+                }
+            }
+            result = ContainmentType.Contains;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="BoundingFrustum"/>.
+        /// </summary>
+        /// <param name="other">The <see cref="BoundingFrustum"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public bool Equals(BoundingFrustum other)
+        {
+            return (this == other);
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="BoundingFrustum"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="Object"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is BoundingFrustum) && this == ((BoundingFrustum)obj);
+        }
+
+        /// <summary>
+        /// Returns a copy of internal corners array.
+        /// </summary>
+        /// <returns>The array of corners.</returns>
+        public Vector3[] GetCorners()
+        {
+            return (Vector3[])this._corners.Clone();
+        }
+
+        /// <summary>
+        /// Returns a copy of internal corners array.
+        /// </summary>
+        /// <param name="corners">The array which values will be replaced to corner values of this instance. It must have size of <see cref="BoundingFrustum.CornerCount"/>.</param>
+		public void GetCorners(Vector3[] corners)
+        {
+			if (corners == null) throw new ArgumentNullException("corners");
+		    if (corners.Length < CornerCount) throw new ArgumentOutOfRangeException("corners");
+
+            this._corners.CopyTo(corners, 0);
+        }
+
+        /// <summary>
+        /// Gets the hash code of this <see cref="BoundingFrustum"/>.
+        /// </summary>
+        /// <returns>Hash code of this <see cref="BoundingFrustum"/>.</returns>
+        public override int GetHashCode()
+        {
+            return this._matrix.GetHashCode();
+        }
+
+        /// <summary>
+        /// Gets whether or not a specified <see cref="BoundingBox"/> intersects with this <see cref="BoundingFrustum"/>.
+        /// </summary>
+        /// <param name="box">A <see cref="BoundingBox"/> for intersection test.</param>
+        /// <returns><c>true</c> if specified <see cref="BoundingBox"/> intersects with this <see cref="BoundingFrustum"/>; <c>false</c> otherwise.</returns>
+        public bool Intersects(BoundingBox box)
+        {
+			var result = false;
+			this.Intersects(ref box, out result);
+			return result;
+        }
+
+        /// <summary>
+        /// Gets whether or not a specified <see cref="BoundingBox"/> intersects with this <see cref="BoundingFrustum"/>.
+        /// </summary>
+        /// <param name="box">A <see cref="BoundingBox"/> for intersection test.</param>
+        /// <param name="result"><c>true</c> if specified <see cref="BoundingBox"/> intersects with this <see cref="BoundingFrustum"/>; <c>false</c> otherwise as an output parameter.</param>
+        public void Intersects(ref BoundingBox box, out bool result)
+        {
+			var containment = default(ContainmentType);
+			this.Contains(ref box, out containment);
+			result = containment != ContainmentType.Disjoint;
+		}
+
+        /// <summary>
+        /// Gets whether or not a specified <see cref="BoundingFrustum"/> intersects with this <see cref="BoundingFrustum"/>.
+        /// </summary>
+        /// <param name="frustum">An other <see cref="BoundingFrustum"/> for intersection test.</param>
+        /// <returns><c>true</c> if other <see cref="BoundingFrustum"/> intersects with this <see cref="BoundingFrustum"/>; <c>false</c> otherwise.</returns>
+        public bool Intersects(BoundingFrustum frustum)
+        {
+            return Contains(frustum) != ContainmentType.Disjoint;
+        }
+
+        /// <summary>
+        /// Gets whether or not a specified <see cref="BoundingSphere"/> intersects with this <see cref="BoundingFrustum"/>.
+        /// </summary>
+        /// <param name="sphere">A <see cref="BoundingSphere"/> for intersection test.</param>
+        /// <returns><c>true</c> if specified <see cref="BoundingSphere"/> intersects with this <see cref="BoundingFrustum"/>; <c>false</c> otherwise.</returns>
+        public bool Intersects(BoundingSphere sphere)
+        {
+            var result = default(bool);
+            this.Intersects(ref sphere, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Gets whether or not a specified <see cref="BoundingSphere"/> intersects with this <see cref="BoundingFrustum"/>.
+        /// </summary>
+        /// <param name="sphere">A <see cref="BoundingSphere"/> for intersection test.</param>
+        /// <param name="result"><c>true</c> if specified <see cref="BoundingSphere"/> intersects with this <see cref="BoundingFrustum"/>; <c>false</c> otherwise as an output parameter.</param>
+        public void Intersects(ref BoundingSphere sphere, out bool result)
+        {
+            var containment = default(ContainmentType);
+            this.Contains(ref sphere, out containment);
+            result = containment != ContainmentType.Disjoint;
+        }
+
+        /// <summary>
+        /// Gets type of intersection between specified <see cref="Plane"/> and this <see cref="BoundingFrustum"/>.
+        /// </summary>
+        /// <param name="plane">A <see cref="Plane"/> for intersection test.</param>
+        /// <returns>A plane intersection type.</returns>
+        public PlaneIntersectionType Intersects(Plane plane)
+        {
+            PlaneIntersectionType result;
+            Intersects(ref plane, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Gets type of intersection between specified <see cref="Plane"/> and this <see cref="BoundingFrustum"/>.
+        /// </summary>
+        /// <param name="plane">A <see cref="Plane"/> for intersection test.</param>
+        /// <param name="result">A plane intersection type as an output parameter.</param>
+        public void Intersects(ref Plane plane, out PlaneIntersectionType result)
+        {
+            result = plane.Intersects(ref _corners[0]);
+            for (int i = 1; i < _corners.Length; i++)
+                if (plane.Intersects(ref _corners[i]) != result)
+                    result = PlaneIntersectionType.Intersecting;
+        }
+        
+        /// <summary>
+        /// Gets the distance of intersection of <see cref="Ray"/> and this <see cref="BoundingFrustum"/> or null if no intersection happens.
+        /// </summary>
+        /// <param name="ray">A <see cref="Ray"/> for intersection test.</param>
+        /// <returns>Distance at which ray intersects with this <see cref="BoundingFrustum"/> or null if no intersection happens.</returns>
+        public float? Intersects(Ray ray)
+        {
+            float? result;
+            Intersects(ref ray, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Gets the distance of intersection of <see cref="Ray"/> and this <see cref="BoundingFrustum"/> or null if no intersection happens.
+        /// </summary>
+        /// <param name="ray">A <see cref="Ray"/> for intersection test.</param>
+        /// <param name="result">Distance at which ray intersects with this <see cref="BoundingFrustum"/> or null if no intersection happens as an output parameter.</param>
+        public void Intersects(ref Ray ray, out float? result)
+        {
+            ContainmentType ctype;
+            this.Contains(ref ray.Position, out ctype);
+
+            switch (ctype)
+            {
+                case ContainmentType.Disjoint:
+                    result = null;
+                    return;
+                case ContainmentType.Contains:
+                    result = 0.0f;
+                    return;
+                case ContainmentType.Intersects:
+                    throw new NotImplementedException();
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        } 
+
+        /// <summary>
+        /// Returns a <see cref="String"/> representation of this <see cref="BoundingFrustum"/> in the format:
+        /// {Near:[nearPlane] Far:[farPlane] Left:[leftPlane] Right:[rightPlane] Top:[topPlane] Bottom:[bottomPlane]}
+        /// </summary>
+        /// <returns><see cref="String"/> representation of this <see cref="BoundingFrustum"/>.</returns>
+        public override string ToString()
+        {
+            return "{Near: " + this._planes[0] +
+                   " Far:" + this._planes[1] +
+                   " Left:" + this._planes[2] +
+                   " Right:" + this._planes[3] +
+                   " Top:" + this._planes[4] +
+                   " Bottom:" + this._planes[5] +
+                   "}";
+        }
+
+        #endregion
+
+        #region Private Methods
+
+        private void CreateCorners()
+        {
+            IntersectionPoint(ref this._planes[0], ref this._planes[2], ref this._planes[4], out this._corners[0]);
+            IntersectionPoint(ref this._planes[0], ref this._planes[3], ref this._planes[4], out this._corners[1]);
+            IntersectionPoint(ref this._planes[0], ref this._planes[3], ref this._planes[5], out this._corners[2]);
+            IntersectionPoint(ref this._planes[0], ref this._planes[2], ref this._planes[5], out this._corners[3]);
+            IntersectionPoint(ref this._planes[1], ref this._planes[2], ref this._planes[4], out this._corners[4]);
+            IntersectionPoint(ref this._planes[1], ref this._planes[3], ref this._planes[4], out this._corners[5]);
+            IntersectionPoint(ref this._planes[1], ref this._planes[3], ref this._planes[5], out this._corners[6]);
+            IntersectionPoint(ref this._planes[1], ref this._planes[2], ref this._planes[5], out this._corners[7]);
+        }
+
+        private void CreatePlanes()
+        {            
+            this._planes[0] = new Plane(-this._matrix.M13, -this._matrix.M23, -this._matrix.M33, -this._matrix.M43);
+            this._planes[1] = new Plane(this._matrix.M13 - this._matrix.M14, this._matrix.M23 - this._matrix.M24, this._matrix.M33 - this._matrix.M34, this._matrix.M43 - this._matrix.M44);
+            this._planes[2] = new Plane(-this._matrix.M14 - this._matrix.M11, -this._matrix.M24 - this._matrix.M21, -this._matrix.M34 - this._matrix.M31, -this._matrix.M44 - this._matrix.M41);
+            this._planes[3] = new Plane(this._matrix.M11 - this._matrix.M14, this._matrix.M21 - this._matrix.M24, this._matrix.M31 - this._matrix.M34, this._matrix.M41 - this._matrix.M44);
+            this._planes[4] = new Plane(this._matrix.M12 - this._matrix.M14, this._matrix.M22 - this._matrix.M24, this._matrix.M32 - this._matrix.M34, this._matrix.M42 - this._matrix.M44);
+            this._planes[5] = new Plane(-this._matrix.M14 - this._matrix.M12, -this._matrix.M24 - this._matrix.M22, -this._matrix.M34 - this._matrix.M32, -this._matrix.M44 - this._matrix.M42);
+            
+            this.NormalizePlane(ref this._planes[0]);
+            this.NormalizePlane(ref this._planes[1]);
+            this.NormalizePlane(ref this._planes[2]);
+            this.NormalizePlane(ref this._planes[3]);
+            this.NormalizePlane(ref this._planes[4]);
+            this.NormalizePlane(ref this._planes[5]);
+        }
+
+        private static void IntersectionPoint(ref Plane a, ref Plane b, ref Plane c, out Vector3 result)
+        {
+            // Formula used
+            //                d1 ( N2 * N3 ) + d2 ( N3 * N1 ) + d3 ( N1 * N2 )
+            //P =   -------------------------------------------------------------------------
+            //                             N1 . ( N2 * N3 )
+            //
+            // Note: N refers to the normal, d refers to the displacement. '.' means dot product. '*' means cross product
+            
+            Vector3 v1, v2, v3;
+            Vector3 cross;
+            
+            Vector3.Cross(ref b.Normal, ref c.Normal, out cross);
+            
+            float f;
+            Vector3.Dot(ref a.Normal, ref cross, out f);
+            f *= -1.0f;
+            
+            Vector3.Cross(ref b.Normal, ref c.Normal, out cross);
+            Vector3.Multiply(ref cross, a.D, out v1);
+            //v1 = (a.D * (Vector3.Cross(b.Normal, c.Normal)));
+            
+            
+            Vector3.Cross(ref c.Normal, ref a.Normal, out cross);
+            Vector3.Multiply(ref cross, b.D, out v2);
+            //v2 = (b.D * (Vector3.Cross(c.Normal, a.Normal)));
+            
+            
+            Vector3.Cross(ref a.Normal, ref b.Normal, out cross);
+            Vector3.Multiply(ref cross, c.D, out v3);
+            //v3 = (c.D * (Vector3.Cross(a.Normal, b.Normal)));
+            
+            result.X = (v1.X + v2.X + v3.X) / f;
+            result.Y = (v1.Y + v2.Y + v3.Y) / f;
+            result.Z = (v1.Z + v2.Z + v3.Z) / f;
+        }
+        
+        private void NormalizePlane(ref Plane p)
+        {
+            float factor = 1f / p.Normal.Length();
+            p.Normal.X *= factor;
+            p.Normal.Y *= factor;
+            p.Normal.Z *= factor;
+            p.D *= factor;
+        }
+
+        #endregion
+    }
+}
+
diff --git a/MonoGame.Framework/BoundingSphere.cs b/MonoGame.Framework/BoundingSphere.cs
new file mode 100644
index 00000000000..7b3b9922232
--- /dev/null
+++ b/MonoGame.Framework/BoundingSphere.cs
@@ -0,0 +1,640 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Describes a sphere in 3D-space for bounding operations.
+    /// </summary>
+    [DataContract]
+    [DebuggerDisplay("{DebugDisplayString,nq}")]
+    public struct BoundingSphere : IEquatable<BoundingSphere>
+    {
+        #region Public Fields
+
+        /// <summary>
+        /// The sphere center.
+        /// </summary>
+        [DataMember]
+        public Vector3 Center;
+
+        /// <summary>
+        /// The sphere radius.
+        /// </summary>
+        [DataMember]
+        public float Radius;
+
+        #endregion
+
+        #region Internal Properties
+
+        internal string DebugDisplayString
+        {
+            get
+            {
+                return string.Concat(
+                    "Center( ", this.Center.DebugDisplayString, " )  \r\n",
+                    "Radius( ", this.Radius.ToString(), " )"
+                    );
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Constructs a bounding sphere with the specified center and radius.  
+        /// </summary>
+        /// <param name="center">The sphere center.</param>
+        /// <param name="radius">The sphere radius.</param>
+        public BoundingSphere(Vector3 center, float radius)
+        {
+            this.Center = center;
+            this.Radius = radius;
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        #region Contains
+
+        /// <summary>
+        /// Test if a bounding box is fully inside, outside, or just intersecting the sphere.
+        /// </summary>
+        /// <param name="box">The box for testing.</param>
+        /// <returns>The containment type.</returns>
+        public ContainmentType Contains(BoundingBox box)
+        {
+            //check if all corner is in sphere
+            bool inside = true;
+            foreach (Vector3 corner in box.GetCorners())
+            {
+                if (this.Contains(corner) == ContainmentType.Disjoint)
+                {
+                    inside = false;
+                    break;
+                }
+            }
+
+            if (inside)
+                return ContainmentType.Contains;
+
+            //check if the distance from sphere center to cube face < radius
+            double dmin = 0;
+
+            if (Center.X < box.Min.X)
+				dmin += (Center.X - box.Min.X) * (Center.X - box.Min.X);
+
+			else if (Center.X > box.Max.X)
+					dmin += (Center.X - box.Max.X) * (Center.X - box.Max.X);
+
+			if (Center.Y < box.Min.Y)
+				dmin += (Center.Y - box.Min.Y) * (Center.Y - box.Min.Y);
+
+			else if (Center.Y > box.Max.Y)
+				dmin += (Center.Y - box.Max.Y) * (Center.Y - box.Max.Y);
+
+			if (Center.Z < box.Min.Z)
+				dmin += (Center.Z - box.Min.Z) * (Center.Z - box.Min.Z);
+
+			else if (Center.Z > box.Max.Z)
+				dmin += (Center.Z - box.Max.Z) * (Center.Z - box.Max.Z);
+
+			if (dmin <= Radius * Radius) 
+				return ContainmentType.Intersects;
+            
+            //else disjoint
+            return ContainmentType.Disjoint;
+        }
+
+        /// <summary>
+        /// Test if a bounding box is fully inside, outside, or just intersecting the sphere.
+        /// </summary>
+        /// <param name="box">The box for testing.</param>
+        /// <param name="result">The containment type as an output parameter.</param>
+        public void Contains(ref BoundingBox box, out ContainmentType result)
+        {
+            result = this.Contains(box);
+        }
+
+        /// <summary>
+        /// Test if a frustum is fully inside, outside, or just intersecting the sphere.
+        /// </summary>
+        /// <param name="frustum">The frustum for testing.</param>
+        /// <returns>The containment type.</returns>
+        public ContainmentType Contains(BoundingFrustum frustum)
+        {
+            //check if all corner is in sphere
+            bool inside = true;
+
+            Vector3[] corners = frustum.GetCorners();
+            foreach (Vector3 corner in corners)
+            {
+                if (this.Contains(corner) == ContainmentType.Disjoint)
+                {
+                    inside = false;
+                    break;
+                }
+            }
+            if (inside)
+                return ContainmentType.Contains;
+
+            //check if the distance from sphere center to frustrum face < radius
+            double dmin = 0;
+            //TODO : calcul dmin
+
+            if (dmin <= Radius * Radius)
+                return ContainmentType.Intersects;
+
+            //else disjoint
+            return ContainmentType.Disjoint;
+        }
+
+        /// <summary>
+        /// Test if a frustum is fully inside, outside, or just intersecting the sphere.
+        /// </summary>
+        /// <param name="frustum">The frustum for testing.</param>
+        /// <param name="result">The containment type as an output parameter.</param>
+        public void Contains(ref BoundingFrustum frustum,out ContainmentType result)
+        {
+            result = this.Contains(frustum);
+        }
+
+        /// <summary>
+        /// Test if a sphere is fully inside, outside, or just intersecting the sphere.
+        /// </summary>
+        /// <param name="sphere">The other sphere for testing.</param>
+        /// <returns>The containment type.</returns>
+        public ContainmentType Contains(BoundingSphere sphere)
+        {
+            ContainmentType result;
+            Contains(ref sphere, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Test if a sphere is fully inside, outside, or just intersecting the sphere.
+        /// </summary>
+        /// <param name="sphere">The other sphere for testing.</param>
+        /// <param name="result">The containment type as an output parameter.</param>
+        public void Contains(ref BoundingSphere sphere, out ContainmentType result)
+        {
+            float sqDistance;
+            Vector3.DistanceSquared(ref sphere.Center, ref Center, out sqDistance);
+
+            if (sqDistance > (sphere.Radius + Radius) * (sphere.Radius + Radius))
+                result = ContainmentType.Disjoint;
+
+            else if (sqDistance <= (Radius - sphere.Radius) * (Radius - sphere.Radius))
+                result = ContainmentType.Contains;
+
+            else
+                result = ContainmentType.Intersects;
+        }
+
+        /// <summary>
+        /// Test if a point is fully inside, outside, or just intersecting the sphere.
+        /// </summary>
+        /// <param name="point">The vector in 3D-space for testing.</param>
+        /// <returns>The containment type.</returns>
+        public ContainmentType Contains(Vector3 point)
+        {
+            ContainmentType result;
+            Contains(ref point, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Test if a point is fully inside, outside, or just intersecting the sphere.
+        /// </summary>
+        /// <param name="point">The vector in 3D-space for testing.</param>
+        /// <param name="result">The containment type as an output parameter.</param>
+        public void Contains(ref Vector3 point, out ContainmentType result)
+        {
+            float sqRadius = Radius * Radius;
+            float sqDistance;
+            Vector3.DistanceSquared(ref point, ref Center, out sqDistance);
+            
+            if (sqDistance > sqRadius)
+                result = ContainmentType.Disjoint;
+
+            else if (sqDistance < sqRadius)
+                result = ContainmentType.Contains;
+
+            else 
+                result = ContainmentType.Intersects;
+        }
+
+        #endregion
+
+        #region CreateFromBoundingBox
+
+        /// <summary>
+        /// Creates the smallest <see cref="BoundingSphere"/> that can contain a specified <see cref="BoundingBox"/>.
+        /// </summary>
+        /// <param name="box">The box to create the sphere from.</param>
+        /// <returns>The new <see cref="BoundingSphere"/>.</returns>
+        public static BoundingSphere CreateFromBoundingBox(BoundingBox box)
+        {
+            BoundingSphere result;
+            CreateFromBoundingBox(ref box, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates the smallest <see cref="BoundingSphere"/> that can contain a specified <see cref="BoundingBox"/>.
+        /// </summary>
+        /// <param name="box">The box to create the sphere from.</param>
+        /// <param name="result">The new <see cref="BoundingSphere"/> as an output parameter.</param>
+        public static void CreateFromBoundingBox(ref BoundingBox box, out BoundingSphere result)
+        {
+            // Find the center of the box.
+            Vector3 center = new Vector3((box.Min.X + box.Max.X) / 2.0f,
+                                         (box.Min.Y + box.Max.Y) / 2.0f,
+                                         (box.Min.Z + box.Max.Z) / 2.0f);
+
+            // Find the distance between the center and one of the corners of the box.
+            float radius = Vector3.Distance(center, box.Max);
+
+            result = new BoundingSphere(center, radius);
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Creates the smallest <see cref="BoundingSphere"/> that can contain a specified <see cref="BoundingFrustum"/>.
+        /// </summary>
+        /// <param name="frustum">The frustum to create the sphere from.</param>
+        /// <returns>The new <see cref="BoundingSphere"/>.</returns>
+        public static BoundingSphere CreateFromFrustum(BoundingFrustum frustum)
+        {
+            return CreateFromPoints(frustum.GetCorners());
+        }
+
+        /// <summary>
+        /// Creates the smallest <see cref="BoundingSphere"/> that can contain a specified list of points in 3D-space. 
+        /// </summary>
+        /// <param name="points">List of point to create the sphere from.</param>
+        /// <returns>The new <see cref="BoundingSphere"/>.</returns>
+        public static BoundingSphere CreateFromPoints(IEnumerable<Vector3> points)
+        {
+            if (points == null )
+                throw new ArgumentNullException("points");
+
+            // From "Real-Time Collision Detection" (Page 89)
+
+            var minx = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
+            var maxx = -minx;
+            var miny = minx;
+            var maxy = -minx;
+            var minz = minx;
+            var maxz = -minx;
+
+            // Find the most extreme points along the principle axis.
+            var numPoints = 0;           
+            foreach (var pt in points)
+            {
+                ++numPoints;
+
+                if (pt.X < minx.X) 
+                    minx = pt;
+                if (pt.X > maxx.X) 
+                    maxx = pt;
+                if (pt.Y < miny.Y) 
+                    miny = pt;
+                if (pt.Y > maxy.Y) 
+                    maxy = pt;
+                if (pt.Z < minz.Z) 
+                    minz = pt;
+                if (pt.Z > maxz.Z) 
+                    maxz = pt;
+            }
+
+            if (numPoints == 0)
+                throw new ArgumentException("You should have at least one point in points.");
+
+            var sqDistX = Vector3.DistanceSquared(maxx, minx);
+            var sqDistY = Vector3.DistanceSquared(maxy, miny);
+            var sqDistZ = Vector3.DistanceSquared(maxz, minz);
+
+            // Pick the pair of most distant points.
+            var min = minx;
+            var max = maxx;
+            if (sqDistY > sqDistX && sqDistY > sqDistZ) 
+            {
+                max = maxy;
+                min = miny;
+            }
+            if (sqDistZ > sqDistX && sqDistZ > sqDistY) 
+            {
+                max = maxz;
+                min = minz;
+            }
+            
+            var center = (min + max) * 0.5f;
+            var radius = Vector3.Distance(max, center);
+            
+            // Test every point and expand the sphere.
+            // The current bounding sphere is just a good approximation and may not enclose all points.            
+            // From: Mathematics for 3D Game Programming and Computer Graphics, Eric Lengyel, Third Edition.
+            // Page 218
+            float sqRadius = radius * radius;
+            foreach (var pt in points)
+            {
+                Vector3 diff = (pt-center);
+                float sqDist = diff.LengthSquared();
+                if (sqDist > sqRadius)
+                {
+                    float distance = (float)Math.Sqrt(sqDist); // equal to diff.Length();
+                    Vector3 direction = diff / distance;
+                    Vector3 G = center - radius * direction;
+                    center = (G + pt) / 2;
+                    radius = Vector3.Distance(pt, center);
+                    sqRadius = radius * radius;
+                }
+            }
+
+            return new BoundingSphere(center, radius);
+        }
+
+        /// <summary>
+        /// Creates the smallest <see cref="BoundingSphere"/> that can contain two spheres.
+        /// </summary>
+        /// <param name="original">First sphere.</param>
+        /// <param name="additional">Second sphere.</param>
+        /// <returns>The new <see cref="BoundingSphere"/>.</returns>
+        public static BoundingSphere CreateMerged(BoundingSphere original, BoundingSphere additional)
+        {
+            BoundingSphere result;
+            CreateMerged(ref original, ref additional, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates the smallest <see cref="BoundingSphere"/> that can contain two spheres.
+        /// </summary>
+        /// <param name="original">First sphere.</param>
+        /// <param name="additional">Second sphere.</param>
+        /// <param name="result">The new <see cref="BoundingSphere"/> as an output parameter.</param>
+        public static void CreateMerged(ref BoundingSphere original, ref BoundingSphere additional, out BoundingSphere result)
+        {
+            Vector3 ocenterToaCenter = Vector3.Subtract(additional.Center, original.Center);
+            float distance = ocenterToaCenter.Length();
+            if (distance <= original.Radius + additional.Radius)//intersect
+            {
+                if (distance <= original.Radius - additional.Radius)//original contain additional
+                {
+                    result = original;
+                    return;
+                }
+                if (distance <= additional.Radius - original.Radius)//additional contain original
+                {
+                    result = additional;
+                    return;
+                }
+            }
+            //else find center of new sphere and radius
+            float leftRadius = Math.Max(original.Radius - distance, additional.Radius);
+            float Rightradius = Math.Max(original.Radius + distance, additional.Radius);
+            ocenterToaCenter = ocenterToaCenter + (((leftRadius - Rightradius) / (2 * ocenterToaCenter.Length())) * ocenterToaCenter);//oCenterToResultCenter
+
+            result = new BoundingSphere();
+            result.Center = original.Center + ocenterToaCenter;
+            result.Radius = (leftRadius + Rightradius) / 2;
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="BoundingSphere"/>.
+        /// </summary>
+        /// <param name="other">The <see cref="BoundingSphere"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public bool Equals(BoundingSphere other)
+        {
+            return this.Center == other.Center && this.Radius == other.Radius;
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Object"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="Object"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            if (obj is BoundingSphere)
+                return this.Equals((BoundingSphere)obj);
+
+            return false;
+        }
+
+        /// <summary>
+        /// Gets the hash code of this <see cref="BoundingSphere"/>.
+        /// </summary>
+        /// <returns>Hash code of this <see cref="BoundingSphere"/>.</returns>
+        public override int GetHashCode()
+        {
+            return this.Center.GetHashCode() + this.Radius.GetHashCode();
+        }
+
+        #region Intersects
+
+        /// <summary>
+        /// Gets whether or not a specified <see cref="BoundingBox"/> intersects with this sphere.
+        /// </summary>
+        /// <param name="box">The box for testing.</param>
+        /// <returns><c>true</c> if <see cref="BoundingBox"/> intersects with this sphere; <c>false</c> otherwise.</returns>
+        public bool Intersects(BoundingBox box)
+        {
+			return box.Intersects(this);
+        }
+
+        /// <summary>
+        /// Gets whether or not a specified <see cref="BoundingBox"/> intersects with this sphere.
+        /// </summary>
+        /// <param name="box">The box for testing.</param>
+        /// <param name="result"><c>true</c> if <see cref="BoundingBox"/> intersects with this sphere; <c>false</c> otherwise. As an output parameter.</param>
+        public void Intersects(ref BoundingBox box, out bool result)
+        {
+            box.Intersects(ref this, out result);
+        }
+
+        /*
+        TODO : Make the public bool Intersects(BoundingFrustum frustum) overload
+
+        public bool Intersects(BoundingFrustum frustum)
+        {
+            if (frustum == null)
+                throw new NullReferenceException();
+
+            throw new NotImplementedException();
+        }
+
+        */
+
+        /// <summary>
+        /// Gets whether or not the other <see cref="BoundingSphere"/> intersects with this sphere.
+        /// </summary>
+        /// <param name="sphere">The other sphere for testing.</param>
+        /// <returns><c>true</c> if other <see cref="BoundingSphere"/> intersects with this sphere; <c>false</c> otherwise.</returns>
+        public bool Intersects(BoundingSphere sphere)
+        {
+            bool result;
+            Intersects(ref sphere, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Gets whether or not the other <see cref="BoundingSphere"/> intersects with this sphere.
+        /// </summary>
+        /// <param name="sphere">The other sphere for testing.</param>
+        /// <param name="result"><c>true</c> if other <see cref="BoundingSphere"/> intersects with this sphere; <c>false</c> otherwise. As an output parameter.</param>
+        public void Intersects(ref BoundingSphere sphere, out bool result)
+        {
+            float sqDistance;
+            Vector3.DistanceSquared(ref sphere.Center, ref Center, out sqDistance);
+
+            if (sqDistance > (sphere.Radius + Radius) * (sphere.Radius + Radius))
+                result = false;
+            else
+                result = true;
+        }
+
+        /// <summary>
+        /// Gets whether or not a specified <see cref="Plane"/> intersects with this sphere.
+        /// </summary>
+        /// <param name="plane">The plane for testing.</param>
+        /// <returns>Type of intersection.</returns>
+        public PlaneIntersectionType Intersects(Plane plane)
+        {
+            var result = default(PlaneIntersectionType);
+            // TODO: we might want to inline this for performance reasons
+            this.Intersects(ref plane, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Gets whether or not a specified <see cref="Plane"/> intersects with this sphere.
+        /// </summary>
+        /// <param name="plane">The plane for testing.</param>
+        /// <param name="result">Type of intersection as an output parameter.</param>
+        public void Intersects(ref Plane plane, out PlaneIntersectionType result)
+        {
+            var distance = default(float);
+            // TODO: we might want to inline this for performance reasons
+            Vector3.Dot(ref plane.Normal, ref this.Center, out distance);
+            distance += plane.D;
+            if (distance > this.Radius)
+                result = PlaneIntersectionType.Front;
+            else if (distance < -this.Radius)
+                result = PlaneIntersectionType.Back;
+            else
+                result = PlaneIntersectionType.Intersecting;
+        }
+
+        /// <summary>
+        /// Gets whether or not a specified <see cref="Ray"/> intersects with this sphere.
+        /// </summary>
+        /// <param name="ray">The ray for testing.</param>
+        /// <returns>Distance of ray intersection or <c>null</c> if there is no intersection.</returns>
+        public float? Intersects(Ray ray)
+        {
+            return ray.Intersects(this);
+        }
+
+        /// <summary>
+        /// Gets whether or not a specified <see cref="Ray"/> intersects with this sphere.
+        /// </summary>
+        /// <param name="ray">The ray for testing.</param>
+        /// <param name="result">Distance of ray intersection or <c>null</c> if there is no intersection as an output parameter.</param>
+        public void Intersects(ref Ray ray, out float? result)
+        {
+            ray.Intersects(ref this, out result);
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Returns a <see cref="String"/> representation of this <see cref="BoundingSphere"/> in the format:
+        /// {Center:[<see cref="Center"/>] Radius:[<see cref="Radius"/>]}
+        /// </summary>
+        /// <returns>A <see cref="String"/> representation of this <see cref="BoundingSphere"/>.</returns>
+        public override string ToString()
+        {
+            return "{Center:" + this.Center + " Radius:" + this.Radius + "}";
+        }
+
+        #region Transform
+
+        /// <summary>
+        /// Creates a new <see cref="BoundingSphere"/> that contains a transformation of translation and scale from this sphere by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <returns>Transformed <see cref="BoundingSphere"/>.</returns>
+        public BoundingSphere Transform(Matrix matrix)
+        {
+            BoundingSphere sphere = new BoundingSphere();
+            sphere.Center = Vector3.Transform(this.Center, matrix);
+            sphere.Radius = this.Radius * ((float)Math.Sqrt((double)Math.Max(((matrix.M11 * matrix.M11) + (matrix.M12 * matrix.M12)) + (matrix.M13 * matrix.M13), Math.Max(((matrix.M21 * matrix.M21) + (matrix.M22 * matrix.M22)) + (matrix.M23 * matrix.M23), ((matrix.M31 * matrix.M31) + (matrix.M32 * matrix.M32)) + (matrix.M33 * matrix.M33)))));
+            return sphere;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="BoundingSphere"/> that contains a transformation of translation and scale from this sphere by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="result">Transformed <see cref="BoundingSphere"/> as an output parameter.</param>
+        public void Transform(ref Matrix matrix, out BoundingSphere result)
+        {
+            result.Center = Vector3.Transform(this.Center, matrix);
+            result.Radius = this.Radius * ((float)Math.Sqrt((double)Math.Max(((matrix.M11 * matrix.M11) + (matrix.M12 * matrix.M12)) + (matrix.M13 * matrix.M13), Math.Max(((matrix.M21 * matrix.M21) + (matrix.M22 * matrix.M22)) + (matrix.M23 * matrix.M23), ((matrix.M31 * matrix.M31) + (matrix.M32 * matrix.M32)) + (matrix.M33 * matrix.M33)))));
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Deconstruction method for <see cref="BoundingSphere"/>.
+        /// </summary>
+        /// <param name="center"></param>
+        /// <param name="radius"></param>
+        public void Deconstruct(out Vector3 center, out float radius)
+        {
+            center = Center;
+            radius = Radius;
+        }
+
+        #endregion
+
+        #region Operators
+
+        /// <summary>
+        /// Compares whether two <see cref="BoundingSphere"/> instances are equal.
+        /// </summary>
+        /// <param name="a"><see cref="BoundingSphere"/> instance on the left of the equal sign.</param>
+        /// <param name="b"><see cref="BoundingSphere"/> instance on the right of the equal sign.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public static bool operator == (BoundingSphere a, BoundingSphere b)
+        {
+            return a.Equals(b);
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="BoundingSphere"/> instances are not equal.
+        /// </summary>
+        /// <param name="a"><see cref="BoundingSphere"/> instance on the left of the not equal sign.</param>
+        /// <param name="b"><see cref="BoundingSphere"/> instance on the right of the not equal sign.</param>
+        /// <returns><c>true</c> if the instances are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator != (BoundingSphere a, BoundingSphere b)
+        {
+            return !a.Equals(b);
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Color.cs b/MonoGame.Framework/Color.cs
new file mode 100644
index 00000000000..78becbafc95
--- /dev/null
+++ b/MonoGame.Framework/Color.cs
@@ -0,0 +1,1901 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Text;
+using System.Runtime.Serialization;
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Describes a 32-bit packed color.
+    /// </summary>
+    [DataContract]
+    [DebuggerDisplay("{DebugDisplayString,nq}")]
+    public struct Color : IEquatable<Color>
+    {
+        static Color()
+        {
+            TransparentBlack = new Color(0);
+            Transparent = new Color(0);
+            AliceBlue = new Color(0xfffff8f0);
+            AntiqueWhite = new Color(0xffd7ebfa);
+            Aqua = new Color(0xffffff00);
+            Aquamarine = new Color(0xffd4ff7f);
+            Azure = new Color(0xfffffff0);
+            Beige = new Color(0xffdcf5f5);
+            Bisque = new Color(0xffc4e4ff);
+            Black = new Color(0xff000000);
+            BlanchedAlmond = new Color(0xffcdebff);
+            Blue = new Color(0xffff0000);
+            BlueViolet = new Color(0xffe22b8a);
+            Brown = new Color(0xff2a2aa5);
+            BurlyWood = new Color(0xff87b8de);
+            CadetBlue = new Color(0xffa09e5f);
+            Chartreuse = new Color(0xff00ff7f);
+            Chocolate = new Color(0xff1e69d2);
+            Coral = new Color(0xff507fff);
+            CornflowerBlue = new Color(0xffed9564);
+            Cornsilk = new Color(0xffdcf8ff);
+            Crimson = new Color(0xff3c14dc);
+            Cyan = new Color(0xffffff00);
+            DarkBlue = new Color(0xff8b0000);
+            DarkCyan = new Color(0xff8b8b00);
+            DarkGoldenrod = new Color(0xff0b86b8);
+            DarkGray = new Color(0xffa9a9a9);
+            DarkGreen = new Color(0xff006400);
+            DarkKhaki = new Color(0xff6bb7bd);
+            DarkMagenta = new Color(0xff8b008b);
+            DarkOliveGreen = new Color(0xff2f6b55);
+            DarkOrange = new Color(0xff008cff);
+            DarkOrchid = new Color(0xffcc3299);
+            DarkRed = new Color(0xff00008b);
+            DarkSalmon = new Color(0xff7a96e9);
+            DarkSeaGreen = new Color(0xff8bbc8f);
+            DarkSlateBlue = new Color(0xff8b3d48);
+            DarkSlateGray = new Color(0xff4f4f2f);
+            DarkTurquoise = new Color(0xffd1ce00);
+            DarkViolet = new Color(0xffd30094);
+            DeepPink = new Color(0xff9314ff);
+            DeepSkyBlue = new Color(0xffffbf00);
+            DimGray = new Color(0xff696969);
+            DodgerBlue = new Color(0xffff901e);
+            Firebrick = new Color(0xff2222b2);
+            FloralWhite = new Color(0xfff0faff);
+            ForestGreen = new Color(0xff228b22);
+            Fuchsia = new Color(0xffff00ff);
+            Gainsboro = new Color(0xffdcdcdc);
+            GhostWhite = new Color(0xfffff8f8);
+            Gold = new Color(0xff00d7ff);
+            Goldenrod = new Color(0xff20a5da);
+            Gray = new Color(0xff808080);
+            Green = new Color(0xff008000);
+            GreenYellow = new Color(0xff2fffad);
+            Honeydew = new Color(0xfff0fff0);
+            HotPink = new Color(0xffb469ff);
+            IndianRed = new Color(0xff5c5ccd);
+            Indigo = new Color(0xff82004b);
+            Ivory = new Color(0xfff0ffff);
+            Khaki = new Color(0xff8ce6f0);
+            Lavender = new Color(0xfffae6e6);
+            LavenderBlush = new Color(0xfff5f0ff);
+            LawnGreen = new Color(0xff00fc7c);
+            LemonChiffon = new Color(0xffcdfaff);
+            LightBlue = new Color(0xffe6d8ad);
+            LightCoral = new Color(0xff8080f0);
+            LightCyan = new Color(0xffffffe0);
+            LightGoldenrodYellow = new Color(0xffd2fafa);
+            LightGray = new Color(0xffd3d3d3);
+            LightGreen = new Color(0xff90ee90);
+            LightPink = new Color(0xffc1b6ff);
+            LightSalmon = new Color(0xff7aa0ff);
+            LightSeaGreen = new Color(0xffaab220);
+            LightSkyBlue = new Color(0xffface87);
+            LightSlateGray = new Color(0xff998877);
+            LightSteelBlue = new Color(0xffdec4b0);
+            LightYellow = new Color(0xffe0ffff);
+            Lime = new Color(0xff00ff00);
+            LimeGreen = new Color(0xff32cd32);
+            Linen = new Color(0xffe6f0fa);
+            Magenta = new Color(0xffff00ff);
+            Maroon = new Color(0xff000080);
+            MediumAquamarine = new Color(0xffaacd66);
+            MediumBlue = new Color(0xffcd0000);
+            MediumOrchid = new Color(0xffd355ba);
+            MediumPurple = new Color(0xffdb7093);
+            MediumSeaGreen = new Color(0xff71b33c);
+            MediumSlateBlue = new Color(0xffee687b);
+            MediumSpringGreen = new Color(0xff9afa00);
+            MediumTurquoise = new Color(0xffccd148);
+            MediumVioletRed = new Color(0xff8515c7);
+            MidnightBlue = new Color(0xff701919);
+            MintCream = new Color(0xfffafff5);
+            MistyRose = new Color(0xffe1e4ff);
+            Moccasin = new Color(0xffb5e4ff);
+            MonoGameOrange = new Color(0xff003ce7);
+            NavajoWhite = new Color(0xffaddeff);
+            Navy = new Color(0xff800000);
+            OldLace = new Color(0xffe6f5fd);
+            Olive = new Color(0xff008080);
+            OliveDrab = new Color(0xff238e6b);
+            Orange = new Color(0xff00a5ff);
+            OrangeRed = new Color(0xff0045ff);
+            Orchid = new Color(0xffd670da);
+            PaleGoldenrod = new Color(0xffaae8ee);
+            PaleGreen = new Color(0xff98fb98);
+            PaleTurquoise = new Color(0xffeeeeaf);
+            PaleVioletRed = new Color(0xff9370db);
+            PapayaWhip = new Color(0xffd5efff);
+            PeachPuff = new Color(0xffb9daff);
+            Peru = new Color(0xff3f85cd);
+            Pink = new Color(0xffcbc0ff);
+            Plum = new Color(0xffdda0dd);
+            PowderBlue = new Color(0xffe6e0b0);
+            Purple = new Color(0xff800080);
+            Red = new Color(0xff0000ff);
+            RosyBrown = new Color(0xff8f8fbc);
+            RoyalBlue = new Color(0xffe16941);
+            SaddleBrown = new Color(0xff13458b);
+            Salmon= new Color(0xff7280fa);
+            SandyBrown = new Color(0xff60a4f4);
+            SeaGreen = new Color(0xff578b2e);
+            SeaShell = new Color(0xffeef5ff);
+            Sienna = new Color(0xff2d52a0);
+            Silver  = new Color(0xffc0c0c0);
+            SkyBlue  = new Color(0xffebce87);
+            SlateBlue= new Color(0xffcd5a6a);
+            SlateGray= new Color(0xff908070);
+            Snow= new Color(0xfffafaff);
+            SpringGreen= new Color(0xff7fff00);
+            SteelBlue= new Color(0xffb48246);
+            Tan= new Color(0xff8cb4d2);
+            Teal= new Color(0xff808000);
+            Thistle= new Color(0xffd8bfd8);
+            Tomato= new Color(0xff4763ff);
+            Turquoise= new Color(0xffd0e040);
+            Violet= new Color(0xffee82ee);
+            Wheat= new Color(0xffb3def5);
+            White= new Color(uint.MaxValue);
+            WhiteSmoke= new Color(0xfff5f5f5);
+            Yellow = new Color(0xff00ffff);
+            YellowGreen = new Color(0xff32cd9a);
+        }
+
+        // Stored as RGBA with R in the least significant octet:
+        // |-------|-------|-------|-------
+        // A       B       G       R
+        private uint _packedValue;
+	  
+        /// <summary>
+        /// Constructs an RGBA color from a packed value.
+        /// The value is a 32-bit unsigned integer, with R in the least significant octet.
+        /// </summary>
+        /// <param name="packedValue">The packed value.</param>
+        [CLSCompliant(false)]
+        public Color(uint packedValue)
+        {
+            _packedValue = packedValue;
+        }
+
+        /// <summary>
+        /// Constructs an RGBA color from the XYZW unit length components of a vector.
+        /// </summary>
+        /// <param name="color">A <see cref="Vector4"/> representing color.</param>
+        public Color(Vector4 color)
+            : this((int)(color.X * 255), (int)(color.Y * 255), (int)(color.Z * 255), (int)(color.W * 255))
+        {
+        }
+
+        /// <summary>
+        /// Constructs an RGBA color from the XYZ unit length components of a vector. Alpha value will be opaque.
+        /// </summary>
+        /// <param name="color">A <see cref="Vector3"/> representing color.</param>
+        public Color(Vector3 color)
+            : this((int)(color.X * 255), (int)(color.Y * 255), (int)(color.Z * 255))
+        {
+        }
+
+        /// <summary>
+        /// Constructs an RGBA color from a <see cref="Color"/> and an alpha value.
+        /// </summary>
+        /// <param name="color">A <see cref="Color"/> for RGB values of new <see cref="Color"/> instance.</param>
+        /// <param name="alpha">The alpha component value from 0 to 255.</param>
+        public Color(Color color, int alpha)
+        {
+            if ((alpha & 0xFFFFFF00) != 0)
+            {
+                var clampedA = (uint)MathHelper.Clamp(alpha, Byte.MinValue, Byte.MaxValue);
+
+                _packedValue = (color._packedValue & 0x00FFFFFF) | (clampedA << 24);
+            }
+            else
+            {
+                _packedValue = (color._packedValue & 0x00FFFFFF) | ((uint)alpha << 24);
+            }
+        }
+
+        /// <summary>
+        /// Constructs an RGBA color from color and alpha value.
+        /// </summary>
+        /// <param name="color">A <see cref="Color"/> for RGB values of new <see cref="Color"/> instance.</param>
+        /// <param name="alpha">Alpha component value from 0.0f to 1.0f.</param>
+        public Color(Color color, float alpha):
+            this(color, (int)(alpha * 255))
+        {
+        }
+
+        /// <summary>
+        /// Constructs an RGBA color from scalars representing red, green and blue values. Alpha value will be opaque.
+        /// </summary>
+        /// <param name="r">Red component value from 0.0f to 1.0f.</param>
+        /// <param name="g">Green component value from 0.0f to 1.0f.</param>
+        /// <param name="b">Blue component value from 0.0f to 1.0f.</param>
+        public Color(float r, float g, float b)
+            : this((int)(r * 255), (int)(g * 255), (int)(b * 255))
+        {
+        }
+
+        /// <summary>
+        /// Constructs an RGBA color from scalars representing red, green, blue and alpha values.
+        /// </summary>
+        /// <param name="r">Red component value from 0.0f to 1.0f.</param>
+        /// <param name="g">Green component value from 0.0f to 1.0f.</param>
+        /// <param name="b">Blue component value from 0.0f to 1.0f.</param>
+        /// <param name="alpha">Alpha component value from 0.0f to 1.0f.</param>
+        public Color(float r, float g, float b, float alpha)
+            : this((int)(r * 255), (int)(g * 255), (int)(b * 255), (int)(alpha * 255))
+        {
+        }
+
+        /// <summary>
+        /// Constructs an RGBA color from scalars representing red, green and blue values. Alpha value will be opaque.
+        /// </summary>
+        /// <param name="r">Red component value from 0 to 255.</param>
+        /// <param name="g">Green component value from 0 to 255.</param>
+        /// <param name="b">Blue component value from 0 to 255.</param>
+        public Color(int r, int g, int b)
+        {
+            _packedValue = 0xFF000000; // A = 255
+
+            if (((r | g | b) & 0xFFFFFF00) != 0)
+            {
+                var clampedR = (uint)MathHelper.Clamp(r, Byte.MinValue, Byte.MaxValue);
+                var clampedG = (uint)MathHelper.Clamp(g, Byte.MinValue, Byte.MaxValue);
+                var clampedB = (uint)MathHelper.Clamp(b, Byte.MinValue, Byte.MaxValue);
+
+                _packedValue |= (clampedB << 16) | (clampedG << 8) | (clampedR);
+            }
+            else
+            {
+                _packedValue |= ((uint)b << 16) | ((uint)g << 8) | ((uint)r);
+            }
+        }
+
+        /// <summary>
+        /// Constructs an RGBA color from scalars representing red, green, blue and alpha values.
+        /// </summary>
+        /// <param name="r">Red component value from 0 to 255.</param>
+        /// <param name="g">Green component value from 0 to 255.</param>
+        /// <param name="b">Blue component value from 0 to 255.</param>
+        /// <param name="alpha">Alpha component value from 0 to 255.</param>
+        public Color(int r, int g, int b, int alpha)
+        {
+            if (((r | g | b | alpha) & 0xFFFFFF00) != 0)
+            {
+                var clampedR = (uint)MathHelper.Clamp(r, Byte.MinValue, Byte.MaxValue);
+                var clampedG = (uint)MathHelper.Clamp(g, Byte.MinValue, Byte.MaxValue);
+                var clampedB = (uint)MathHelper.Clamp(b, Byte.MinValue, Byte.MaxValue);
+                var clampedA = (uint)MathHelper.Clamp(alpha, Byte.MinValue, Byte.MaxValue);
+
+                _packedValue = (clampedA << 24) | (clampedB << 16) | (clampedG << 8) | (clampedR);
+            }
+            else
+            {
+                _packedValue = ((uint)alpha << 24) | ((uint)b << 16) | ((uint)g << 8) | ((uint)r);
+            }
+        }
+
+        /// <summary>
+        /// Constructs an RGBA color from scalars representing red, green, blue and alpha values.
+        /// </summary>
+        /// <remarks>
+        /// This overload sets the values directly without clamping, and may therefore be faster than the other overloads.
+        /// </remarks>
+        /// <param name="r"></param>
+        /// <param name="g"></param>
+        /// <param name="b"></param>
+        /// <param name="alpha"></param>
+        public Color(byte r, byte g, byte b, byte alpha)
+        {
+            _packedValue = ((uint)alpha << 24) | ((uint)b << 16) | ((uint)g << 8) | (r);
+        }
+
+        /// <summary>
+        /// Gets or sets the blue component.
+        /// </summary>
+        [DataMember]
+        public byte B
+        {
+            get
+            {
+                unchecked
+                {
+                    return (byte) (this._packedValue >> 16);
+                }
+            }
+            set
+            {
+                this._packedValue = (this._packedValue & 0xff00ffff) | ((uint)value << 16);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the green component.
+        /// </summary>
+        [DataMember]
+        public byte G
+        {
+            get
+            {
+                unchecked
+                {
+                    return (byte)(this._packedValue >> 8);
+                }
+            }
+            set
+            {
+                this._packedValue = (this._packedValue & 0xffff00ff) | ((uint)value << 8);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the red component.
+        /// </summary>
+        [DataMember]
+        public byte R
+        {
+            get
+            {
+                unchecked
+                {
+                    return (byte) this._packedValue;
+                }
+            }
+            set
+            {
+                this._packedValue = (this._packedValue & 0xffffff00) | value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the alpha component.
+        /// </summary>
+        [DataMember]
+        public byte A
+        {
+            get
+            {
+                unchecked
+                {
+                    return (byte)(this._packedValue >> 24);
+                }
+            }
+            set
+            {
+                this._packedValue = (this._packedValue & 0x00ffffff) | ((uint)value << 24);
+            }
+        }
+		
+	/// <summary>
+        /// Compares whether two <see cref="Color"/> instances are equal.
+        /// </summary>
+        /// <param name="a"><see cref="Color"/> instance on the left of the equal sign.</param>
+        /// <param name="b"><see cref="Color"/> instance on the right of the equal sign.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Color a, Color b)
+        {
+            return (a._packedValue == b._packedValue);
+        }
+	
+	/// <summary>
+        /// Compares whether two <see cref="Color"/> instances are not equal.
+        /// </summary>
+        /// <param name="a"><see cref="Color"/> instance on the left of the not equal sign.</param>
+        /// <param name="b"><see cref="Color"/> instance on the right of the not equal sign.</param>
+        /// <returns><c>true</c> if the instances are not equal; <c>false</c> otherwise.</returns>	
+        public static bool operator !=(Color a, Color b)
+        {
+            return (a._packedValue != b._packedValue);
+        }
+
+        /// <summary>
+        /// Gets the hash code of this <see cref="Color"/>.
+        /// </summary>
+        /// <returns>Hash code of this <see cref="Color"/>.</returns>
+        public override int GetHashCode()
+        {
+            return this._packedValue.GetHashCode();
+        }
+	
+        /// <summary>
+        /// Compares whether current instance is equal to specified object.
+        /// </summary>
+        /// <param name="obj">The <see cref="Color"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            return ((obj is Color) && this.Equals((Color)obj));
+        }
+
+        #region Color Bank
+        /// <summary>
+        /// TransparentBlack color (R:0,G:0,B:0,A:0).
+        /// </summary>
+        public static Color TransparentBlack
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Transparent color (R:0,G:0,B:0,A:0).
+        /// </summary>
+        public static Color Transparent
+        {
+            get;
+            private set;
+        }
+	
+	/// <summary>
+        /// AliceBlue color (R:240,G:248,B:255,A:255).
+        /// </summary>
+        public static Color AliceBlue
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// AntiqueWhite color (R:250,G:235,B:215,A:255).
+        /// </summary>
+        public static Color AntiqueWhite
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Aqua color (R:0,G:255,B:255,A:255).
+        /// </summary>
+	public static Color Aqua
+        {
+            get;
+            private set;
+        }
+	
+	/// <summary>
+        /// Aquamarine color (R:127,G:255,B:212,A:255).
+        /// </summary>
+        public static Color Aquamarine
+    {
+        get;
+        private set;
+    }
+        
+        /// <summary>
+        /// Azure color (R:240,G:255,B:255,A:255).
+        /// </summary>
+	public static Color Azure
+        {
+            get;
+            private set;
+        }
+	
+	/// <summary>
+        /// Beige color (R:245,G:245,B:220,A:255).
+        /// </summary>
+        public static Color Beige
+    {
+        get;
+        private set;
+    }
+        
+        /// <summary>
+        /// Bisque color (R:255,G:228,B:196,A:255).
+        /// </summary>
+        public static Color Bisque
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Black color (R:0,G:0,B:0,A:255).
+        /// </summary>
+        public static Color Black
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// BlanchedAlmond color (R:255,G:235,B:205,A:255).
+        /// </summary>
+        public static Color BlanchedAlmond
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Blue color (R:0,G:0,B:255,A:255).
+        /// </summary>
+        public static Color Blue
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// BlueViolet color (R:138,G:43,B:226,A:255).
+        /// </summary>
+        public static Color BlueViolet
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Brown color (R:165,G:42,B:42,A:255).
+        /// </summary>
+        public static Color Brown
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// BurlyWood color (R:222,G:184,B:135,A:255).
+        /// </summary>
+        public static Color BurlyWood
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// CadetBlue color (R:95,G:158,B:160,A:255).
+        /// </summary>
+        public static Color CadetBlue
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Chartreuse color (R:127,G:255,B:0,A:255).
+        /// </summary>
+        public static Color Chartreuse
+        {
+            get;
+            private set;
+        }
+         
+        /// <summary>
+        /// Chocolate color (R:210,G:105,B:30,A:255).
+        /// </summary>
+        public static Color Chocolate
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Coral color (R:255,G:127,B:80,A:255).
+        /// </summary>
+        public static Color Coral
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// CornflowerBlue color (R:100,G:149,B:237,A:255).
+        /// </summary>
+        public static Color CornflowerBlue
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Cornsilk color (R:255,G:248,B:220,A:255).
+        /// </summary>
+	public static Color Cornsilk
+        {
+            get;
+            private set;
+        }
+	
+	/// <summary>
+        /// Crimson color (R:220,G:20,B:60,A:255).
+        /// </summary>
+        public static Color Crimson
+    {
+        get;
+        private set;
+    }
+        
+        /// <summary>
+        /// Cyan color (R:0,G:255,B:255,A:255).
+        /// </summary>
+        public static Color Cyan
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// DarkBlue color (R:0,G:0,B:139,A:255).
+        /// </summary>
+	public static Color DarkBlue
+        {
+            get;
+            private set;
+        }
+	
+	/// <summary>
+        /// DarkCyan color (R:0,G:139,B:139,A:255).
+        /// </summary>
+        public static Color DarkCyan
+    {
+        get;
+        private set;
+    }
+        
+        /// <summary>
+        /// DarkGoldenrod color (R:184,G:134,B:11,A:255).
+        /// </summary>
+        public static Color DarkGoldenrod
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// DarkGray color (R:169,G:169,B:169,A:255).
+        /// </summary>
+	public static Color DarkGray
+        {
+            get;
+            private set;
+        }
+	
+	/// <summary>
+        /// DarkGreen color (R:0,G:100,B:0,A:255).
+        /// </summary>
+        public static Color DarkGreen
+    {
+        get;
+        private set;
+    }
+        
+        /// <summary>
+        /// DarkKhaki color (R:189,G:183,B:107,A:255).
+        /// </summary>
+        public static Color DarkKhaki
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// DarkMagenta color (R:139,G:0,B:139,A:255).
+        /// </summary>
+        public static Color DarkMagenta
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// DarkOliveGreen color (R:85,G:107,B:47,A:255).
+        /// </summary>
+        public static Color DarkOliveGreen
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// DarkOrange color (R:255,G:140,B:0,A:255).
+        /// </summary>
+        public static Color DarkOrange
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// DarkOrchid color (R:153,G:50,B:204,A:255).
+        /// </summary>
+        public static Color DarkOrchid
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// DarkRed color (R:139,G:0,B:0,A:255).
+        /// </summary>
+        public static Color DarkRed
+        {
+            get;
+            private set;
+        }
+        
+	/// <summary>
+        /// DarkSalmon color (R:233,G:150,B:122,A:255).
+        /// </summary>
+        public static Color DarkSalmon
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// DarkSeaGreen color (R:143,G:188,B:139,A:255).
+        /// </summary>
+        public static Color DarkSeaGreen
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// DarkSlateBlue color (R:72,G:61,B:139,A:255).
+        /// </summary>
+        public static Color DarkSlateBlue
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// DarkSlateGray color (R:47,G:79,B:79,A:255).
+        /// </summary>
+        public static Color DarkSlateGray
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// DarkTurquoise color (R:0,G:206,B:209,A:255).
+        /// </summary>
+        public static Color DarkTurquoise
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// DarkViolet color (R:148,G:0,B:211,A:255).
+        /// </summary>
+        public static Color DarkViolet
+        {
+            get;
+            private set;
+        }
+         
+        /// <summary>
+        /// DeepPink color (R:255,G:20,B:147,A:255).
+        /// </summary>
+        public static Color DeepPink
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// DeepSkyBlue color (R:0,G:191,B:255,A:255).
+        /// </summary>
+        public static Color DeepSkyBlue
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// DimGray color (R:105,G:105,B:105,A:255).
+        /// </summary>
+        public static Color DimGray
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// DodgerBlue color (R:30,G:144,B:255,A:255).
+        /// </summary>
+        public static Color DodgerBlue
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Firebrick color (R:178,G:34,B:34,A:255).
+        /// </summary>
+        public static Color Firebrick
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// FloralWhite color (R:255,G:250,B:240,A:255).
+        /// </summary>
+        public static Color FloralWhite
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// ForestGreen color (R:34,G:139,B:34,A:255).
+        /// </summary>
+        public static Color ForestGreen
+        {
+            get;
+            private set;
+        }
+        
+	/// <summary>
+        /// Fuchsia color (R:255,G:0,B:255,A:255).
+        /// </summary>
+        public static Color Fuchsia
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Gainsboro color (R:220,G:220,B:220,A:255).
+        /// </summary>
+        public static Color Gainsboro
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// GhostWhite color (R:248,G:248,B:255,A:255).
+        /// </summary>
+        public static Color GhostWhite
+        {
+            get;
+            private set;
+        }
+        /// <summary>
+        /// Gold color (R:255,G:215,B:0,A:255).
+        /// </summary>
+        public static Color Gold
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Goldenrod color (R:218,G:165,B:32,A:255).
+        /// </summary>
+        public static Color Goldenrod
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Gray color (R:128,G:128,B:128,A:255).
+        /// </summary>
+        public static Color Gray
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Green color (R:0,G:128,B:0,A:255).
+        /// </summary>
+        public static Color Green
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// GreenYellow color (R:173,G:255,B:47,A:255).
+        /// </summary>
+        public static Color GreenYellow
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Honeydew color (R:240,G:255,B:240,A:255).
+        /// </summary>
+        public static Color Honeydew
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// HotPink color (R:255,G:105,B:180,A:255).
+        /// </summary>
+        public static Color HotPink
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// IndianRed color (R:205,G:92,B:92,A:255).
+        /// </summary>
+        public static Color IndianRed
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Indigo color (R:75,G:0,B:130,A:255).
+        /// </summary>
+        public static Color Indigo
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Ivory color (R:255,G:255,B:240,A:255).
+        /// </summary>
+        public static Color Ivory
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Khaki color (R:240,G:230,B:140,A:255).
+        /// </summary>
+        public static Color Khaki
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Lavender color (R:230,G:230,B:250,A:255).
+        /// </summary>
+        public static Color Lavender
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// LavenderBlush color (R:255,G:240,B:245,A:255).
+        /// </summary>
+        public static Color LavenderBlush
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// LawnGreen color (R:124,G:252,B:0,A:255).
+        /// </summary>
+        public static Color LawnGreen
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// LemonChiffon color (R:255,G:250,B:205,A:255).
+        /// </summary>
+        public static Color LemonChiffon
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// LightBlue color (R:173,G:216,B:230,A:255).
+        /// </summary>
+        public static Color LightBlue
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// LightCoral color (R:240,G:128,B:128,A:255).
+        /// </summary>
+        public static Color LightCoral
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// LightCyan color (R:224,G:255,B:255,A:255).
+        /// </summary>
+        public static Color LightCyan
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// LightGoldenrodYellow color (R:250,G:250,B:210,A:255).
+        /// </summary>
+        public static Color LightGoldenrodYellow
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// LightGray color (R:211,G:211,B:211,A:255).
+        /// </summary>
+        public static Color LightGray
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// LightGreen color (R:144,G:238,B:144,A:255).
+        /// </summary>
+        public static Color LightGreen
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// LightPink color (R:255,G:182,B:193,A:255).
+        /// </summary>
+        public static Color LightPink
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// LightSalmon color (R:255,G:160,B:122,A:255).
+        /// </summary>
+        public static Color LightSalmon
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// LightSeaGreen color (R:32,G:178,B:170,A:255).
+        /// </summary>
+        public static Color LightSeaGreen
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// LightSkyBlue color (R:135,G:206,B:250,A:255).
+        /// </summary>
+        public static Color LightSkyBlue
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// LightSlateGray color (R:119,G:136,B:153,A:255).
+        /// </summary>
+        public static Color LightSlateGray
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// LightSteelBlue color (R:176,G:196,B:222,A:255).
+        /// </summary>
+        public static Color LightSteelBlue
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// LightYellow color (R:255,G:255,B:224,A:255).
+        /// </summary>
+        public static Color LightYellow
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Lime color (R:0,G:255,B:0,A:255).
+        /// </summary>
+        public static Color Lime
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// LimeGreen color (R:50,G:205,B:50,A:255).
+        /// </summary>
+        public static Color LimeGreen
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Linen color (R:250,G:240,B:230,A:255).
+        /// </summary>
+        public static Color Linen
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Magenta color (R:255,G:0,B:255,A:255).
+        /// </summary>
+        public static Color Magenta
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Maroon color (R:128,G:0,B:0,A:255).
+        /// </summary>
+        public static Color Maroon
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// MediumAquamarine color (R:102,G:205,B:170,A:255).
+        /// </summary>
+        public static Color MediumAquamarine
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// MediumBlue color (R:0,G:0,B:205,A:255).
+        /// </summary>
+        public static Color MediumBlue
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// MediumOrchid color (R:186,G:85,B:211,A:255).
+        /// </summary>
+        public static Color MediumOrchid
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// MediumPurple color (R:147,G:112,B:219,A:255).
+        /// </summary>
+        public static Color MediumPurple
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// MediumSeaGreen color (R:60,G:179,B:113,A:255).
+        /// </summary>
+        public static Color MediumSeaGreen
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// MediumSlateBlue color (R:123,G:104,B:238,A:255).
+        /// </summary>
+        public static Color MediumSlateBlue
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// MediumSpringGreen color (R:0,G:250,B:154,A:255).
+        /// </summary>
+        public static Color MediumSpringGreen
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// MediumTurquoise color (R:72,G:209,B:204,A:255).
+        /// </summary>
+        public static Color MediumTurquoise
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// MediumVioletRed color (R:199,G:21,B:133,A:255).
+        /// </summary>
+        public static Color MediumVioletRed
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// MidnightBlue color (R:25,G:25,B:112,A:255).
+        /// </summary>
+        public static Color MidnightBlue
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// MintCream color (R:245,G:255,B:250,A:255).
+        /// </summary>
+        public static Color MintCream
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// MistyRose color (R:255,G:228,B:225,A:255).
+        /// </summary>
+        public static Color MistyRose
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Moccasin color (R:255,G:228,B:181,A:255).
+        /// </summary>
+        public static Color Moccasin
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// MonoGame orange theme color (R:231,G:60,B:0,A:255).
+        /// </summary>
+        public static Color MonoGameOrange
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// NavajoWhite color (R:255,G:222,B:173,A:255).
+        /// </summary>
+        public static Color NavajoWhite
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Navy color (R:0,G:0,B:128,A:255).
+        /// </summary>
+        public static Color Navy
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// OldLace color (R:253,G:245,B:230,A:255).
+        /// </summary>
+        public static Color OldLace
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Olive color (R:128,G:128,B:0,A:255).
+        /// </summary>
+        public static Color Olive
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// OliveDrab color (R:107,G:142,B:35,A:255).
+        /// </summary>
+        public static Color OliveDrab
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Orange color (R:255,G:165,B:0,A:255).
+        /// </summary>
+        public static Color Orange
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// OrangeRed color (R:255,G:69,B:0,A:255).
+        /// </summary>
+        public static Color OrangeRed
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Orchid color (R:218,G:112,B:214,A:255).
+        /// </summary>
+        public static Color Orchid
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// PaleGoldenrod color (R:238,G:232,B:170,A:255).
+        /// </summary>
+        public static Color PaleGoldenrod
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// PaleGreen color (R:152,G:251,B:152,A:255).
+        /// </summary>
+        public static Color PaleGreen
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// PaleTurquoise color (R:175,G:238,B:238,A:255).
+        /// </summary>
+        public static Color PaleTurquoise
+        {
+            get;
+            private set;
+        }
+        /// <summary>
+        /// PaleVioletRed color (R:219,G:112,B:147,A:255).
+        /// </summary>
+        public static Color PaleVioletRed
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// PapayaWhip color (R:255,G:239,B:213,A:255).
+        /// </summary>
+        public static Color PapayaWhip
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// PeachPuff color (R:255,G:218,B:185,A:255).
+        /// </summary>
+        public static Color PeachPuff
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Peru color (R:205,G:133,B:63,A:255).
+        /// </summary>
+        public static Color Peru
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Pink color (R:255,G:192,B:203,A:255).
+        /// </summary>
+        public static Color Pink
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Plum color (R:221,G:160,B:221,A:255).
+        /// </summary>
+        public static Color Plum
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// PowderBlue color (R:176,G:224,B:230,A:255).
+        /// </summary>
+        public static Color PowderBlue
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        ///  Purple color (R:128,G:0,B:128,A:255).
+        /// </summary>
+        public static Color Purple
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Red color (R:255,G:0,B:0,A:255).
+        /// </summary>
+        public static Color Red
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// RosyBrown color (R:188,G:143,B:143,A:255).
+        /// </summary>
+        public static Color RosyBrown
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// RoyalBlue color (R:65,G:105,B:225,A:255).
+        /// </summary>
+        public static Color RoyalBlue
+        {
+            get;
+            private set;
+        }
+
+    	/// <summary>
+        /// SaddleBrown color (R:139,G:69,B:19,A:255).
+        /// </summary>
+        public static Color SaddleBrown
+        {
+            get;
+            private set;
+        }
+    	 
+        /// <summary>
+        /// Salmon color (R:250,G:128,B:114,A:255).
+        /// </summary>
+        public static Color Salmon
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// SandyBrown color (R:244,G:164,B:96,A:255).
+        /// </summary>
+        public static Color SandyBrown
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// SeaGreen color (R:46,G:139,B:87,A:255).
+        /// </summary>
+        public static Color SeaGreen
+        {
+            get;
+            private set;
+        }
+        
+    	/// <summary>
+        /// SeaShell color (R:255,G:245,B:238,A:255).
+        /// </summary>
+        public static Color SeaShell
+        {
+            get;
+            private set;
+        }
+        
+    	/// <summary>
+        /// Sienna color (R:160,G:82,B:45,A:255).
+        /// </summary>
+        public static Color Sienna
+        {
+            get;
+            private set;
+        }
+        
+    	/// <summary>
+        /// Silver color (R:192,G:192,B:192,A:255).
+        /// </summary>
+        public static Color Silver
+        {
+            get;
+            private set;
+        }
+        
+       /// <summary>
+       /// SkyBlue color (R:135,G:206,B:235,A:255).
+       /// </summary>
+       public static Color SkyBlue
+        {
+            get;
+            private set;
+        }
+       
+        /// <summary>
+        /// SlateBlue color (R:106,G:90,B:205,A:255).
+        /// </summary>
+        public static Color SlateBlue
+       {
+           get;
+           private set;
+       }
+      
+        /// <summary>
+        /// SlateGray color (R:112,G:128,B:144,A:255).
+        /// </summary>
+        public static Color SlateGray
+        {
+            get;
+            private set;
+        }
+      
+        /// <summary>
+        /// Snow color (R:255,G:250,B:250,A:255).
+        /// </summary>
+        public static Color Snow
+        {
+            get;
+            private set;
+        }
+      
+        /// <summary>
+        /// SpringGreen color (R:0,G:255,B:127,A:255).
+        /// </summary>
+        public static Color SpringGreen
+        {
+            get;
+            private set;
+        }
+      
+        /// <summary>
+        /// SteelBlue color (R:70,G:130,B:180,A:255).
+        /// </summary>
+        public static Color SteelBlue
+        {
+            get;
+            private set;
+        }
+      
+        /// <summary>
+        /// Tan color (R:210,G:180,B:140,A:255).
+        /// </summary>
+        public static Color Tan
+        {
+            get;
+            private set;
+        }
+       
+        /// <summary>
+        /// Teal color (R:0,G:128,B:128,A:255).
+        /// </summary>
+        public static Color Teal
+        {
+            get;
+            private set;
+        }
+       
+        /// <summary>
+        /// Thistle color (R:216,G:191,B:216,A:255).
+        /// </summary>
+        public static Color Thistle
+        {
+            get;
+            private set;
+        }
+       
+        /// <summary>
+        /// Tomato color (R:255,G:99,B:71,A:255).
+        /// </summary>
+        public static Color Tomato
+        {
+            get;
+            private set;
+        }
+        
+    	/// <summary>
+        /// Turquoise color (R:64,G:224,B:208,A:255).
+        /// </summary>
+        public static Color Turquoise
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Violet color (R:238,G:130,B:238,A:255).
+        /// </summary>
+        public static Color Violet
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Wheat color (R:245,G:222,B:179,A:255).
+        /// </summary>
+	public static Color Wheat
+        {
+            get;
+            private set;
+        }
+	
+        /// <summary>
+        /// White color (R:255,G:255,B:255,A:255).
+        /// </summary>
+        public static Color White
+    {
+        get;
+        private set;
+    }
+       
+        /// <summary>
+        /// WhiteSmoke color (R:245,G:245,B:245,A:255).
+        /// </summary>
+        public static Color WhiteSmoke
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// Yellow color (R:255,G:255,B:0,A:255).
+        /// </summary>
+        public static Color Yellow
+        {
+            get;
+            private set;
+        }
+        
+        /// <summary>
+        /// YellowGreen color (R:154,G:205,B:50,A:255).
+        /// </summary>
+        public static Color YellowGreen
+        {
+            get;
+            private set;
+        }
+        #endregion
+
+        /// <summary>
+        /// Performs linear interpolation of <see cref="Color"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Color"/>.</param>
+        /// <param name="value2">Destination <see cref="Color"/>.</param>
+        /// <param name="amount">Interpolation factor.</param>
+        /// <returns>Interpolated <see cref="Color"/>.</returns>
+        public static Color Lerp(Color value1, Color value2, Single amount)
+        {
+			amount = MathHelper.Clamp(amount, 0, 1);
+            return new Color(   
+                (int)MathHelper.Lerp(value1.R, value2.R, amount),
+                (int)MathHelper.Lerp(value1.G, value2.G, amount),
+                (int)MathHelper.Lerp(value1.B, value2.B, amount),
+                (int)MathHelper.Lerp(value1.A, value2.A, amount) );
+        }
+
+        /// <summary>
+        /// <see cref="Color.Lerp"/> should be used instead of this function.
+        /// </summary>
+        /// <returns>Interpolated <see cref="Color"/>.</returns>
+        [Obsolete("Color.Lerp should be used instead of this function.")]
+        public static Color LerpPrecise(Color value1, Color value2, Single amount)
+        {
+            amount = MathHelper.Clamp(amount, 0, 1);
+            return new Color(
+                (int)MathHelper.LerpPrecise(value1.R, value2.R, amount),
+                (int)MathHelper.LerpPrecise(value1.G, value2.G, amount),
+                (int)MathHelper.LerpPrecise(value1.B, value2.B, amount),
+                (int)MathHelper.LerpPrecise(value1.A, value2.A, amount));
+        }
+		
+	/// <summary>
+        /// Multiply <see cref="Color"/> by value.
+        /// </summary>
+        /// <param name="value">Source <see cref="Color"/>.</param>
+        /// <param name="scale">Multiplicator.</param>
+        /// <returns>Multiplication result.</returns>
+	public static Color Multiply(Color value, float scale)
+	{
+	    return new Color((int)(value.R * scale), (int)(value.G * scale), (int)(value.B * scale), (int)(value.A * scale));
+	}
+	
+	/// <summary>
+        /// Multiply <see cref="Color"/> by value.
+        /// </summary>
+        /// <param name="value">Source <see cref="Color"/>.</param>
+        /// <param name="scale">Multiplicator.</param>
+        /// <returns>Multiplication result.</returns>
+	public static Color operator *(Color value, float scale)
+        {
+            return new Color((int)(value.R * scale), (int)(value.G * scale), (int)(value.B * scale), (int)(value.A * scale));
+        }
+
+        /// <summary>
+        /// Gets a <see cref="Vector3"/> representation for this object.
+        /// </summary>
+        /// <returns>A <see cref="Vector3"/> representation for this object.</returns>
+        public Vector3 ToVector3()
+        {
+            return new Vector3(R / 255.0f, G / 255.0f, B / 255.0f);
+        }
+
+        /// <summary>
+        /// Gets a <see cref="Vector4"/> representation for this object.
+        /// </summary>
+        /// <returns>A <see cref="Vector4"/> representation for this object.</returns>
+        public Vector4 ToVector4()
+        {
+            return new Vector4(R / 255.0f, G / 255.0f, B / 255.0f, A / 255.0f);
+        }
+	
+        /// <summary>
+        /// Gets or sets packed value of this <see cref="Color"/>.
+        /// </summary>
+        [CLSCompliant(false)]
+        public UInt32 PackedValue
+        {
+            get { return _packedValue; }
+            set { _packedValue = value; }
+        }
+
+
+        internal string DebugDisplayString
+        {
+            get
+            {
+                return string.Concat(
+                    this.R.ToString(), "  ",
+                    this.G.ToString(), "  ",
+                    this.B.ToString(), "  ",
+                    this.A.ToString()
+                );
+            }
+        }
+
+
+        /// <summary>
+        /// Returns a <see cref="String"/> representation of this <see cref="Color"/> in the format:
+        /// {R:[red] G:[green] B:[blue] A:[alpha]}
+        /// </summary>
+        /// <returns><see cref="String"/> representation of this <see cref="Color"/>.</returns>
+	public override string ToString ()
+	{
+        StringBuilder sb = new StringBuilder(25);
+        sb.Append("{R:");
+        sb.Append(R);
+        sb.Append(" G:");
+        sb.Append(G);
+        sb.Append(" B:");
+        sb.Append(B);
+        sb.Append(" A:");
+        sb.Append(A);
+        sb.Append("}");
+        return sb.ToString();
+	}
+	
+	/// <summary>
+        /// Translate a non-premultipled alpha <see cref="Color"/> to a <see cref="Color"/> that contains premultiplied alpha.
+        /// </summary>
+        /// <param name="vector">A <see cref="Vector4"/> representing color.</param>
+        /// <returns>A <see cref="Color"/> which contains premultiplied alpha data.</returns>
+        public static Color FromNonPremultiplied(Vector4 vector)
+        {
+            return new Color(vector.X * vector.W, vector.Y * vector.W, vector.Z * vector.W, vector.W);
+        }
+	
+	/// <summary>
+        /// Translate a non-premultipled alpha <see cref="Color"/> to a <see cref="Color"/> that contains premultiplied alpha.
+        /// </summary>
+        /// <param name="r">Red component value.</param>
+        /// <param name="g">Green component value.</param>
+        /// <param name="b">Blue component value.</param>
+        /// <param name="a">Alpha component value.</param>
+        /// <returns>A <see cref="Color"/> which contains premultiplied alpha data.</returns>
+        public static Color FromNonPremultiplied(int r, int g, int b, int a)
+        {
+            return new Color(r * a / 255, g * a / 255, b * a / 255, a);
+        }
+
+        #region IEquatable<Color> Members
+	
+	/// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Color"/>.
+        /// </summary>
+        /// <param name="other">The <see cref="Color"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public bool Equals(Color other)
+        {
+	    return this.PackedValue == other.PackedValue;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Deconstruction method for <see cref="Color"/>.
+        /// </summary>
+        /// <param name="r"></param>
+        /// <param name="g"></param>
+        /// <param name="b"></param>
+        public void Deconstruct(out float r, out float g, out float b)
+        {
+            r = R;
+            g = G;
+            b = B;
+        }
+
+        /// <summary>
+        /// Deconstruction method for <see cref="Color"/> with Alpha.
+        /// </summary>
+        /// <param name="r"></param>
+        /// <param name="g"></param>
+        /// <param name="b"></param>
+        /// <param name="a"></param>
+        public void Deconstruct(out float r, out float g, out float b, out float a)
+        {
+            r = R;
+            g = G;
+            b = B;
+            a = A;
+        }
+    }
+}
diff --git a/MonoGame.Framework/ContainmentType.cs b/MonoGame.Framework/ContainmentType.cs
new file mode 100644
index 00000000000..f24039d46b4
--- /dev/null
+++ b/MonoGame.Framework/ContainmentType.cs
@@ -0,0 +1,25 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Defines how the bounding volumes intersects or contain one another.
+    /// </summary>
+    public enum ContainmentType
+    {
+        /// <summary>
+        /// Indicates that there is no overlap between two bounding volumes.
+        /// </summary>
+        Disjoint,
+        /// <summary>
+        /// Indicates that one bounding volume completely contains another volume.
+        /// </summary>
+        Contains,
+        /// <summary>
+        /// Indicates that bounding volumes partially overlap one another.
+        /// </summary>
+        Intersects
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Content/ContentExtensions.cs b/MonoGame.Framework/Content/ContentExtensions.cs
new file mode 100644
index 00000000000..1b6dac6e37f
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentExtensions.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Reflection;
+using System.Linq;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal static class ContentExtensions
+    {
+        public static ConstructorInfo GetDefaultConstructor(this Type type)
+        {
+#if NET45
+            var typeInfo = type.GetTypeInfo();
+            var ctor = typeInfo.DeclaredConstructors.FirstOrDefault(c => !c.IsStatic && c.GetParameters().Length == 0);
+            return ctor;
+#else
+            var attrs = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;
+            return type.GetConstructor(attrs, null, new Type[0], null);
+#endif
+        }
+
+        public static PropertyInfo[] GetAllProperties(this Type type)
+        {
+
+            // Sometimes, overridden properties of abstract classes can show up even with 
+            // BindingFlags.DeclaredOnly is passed to GetProperties. Make sure that
+            // all properties in this list are defined in this class by comparing
+            // its get method with that of it's base class. If they're the same
+            // Then it's an overridden property.
+#if NET45
+            PropertyInfo[] infos= type.GetTypeInfo().DeclaredProperties.ToArray();
+            var nonStaticPropertyInfos = from p in infos
+                                         where (p.GetMethod != null) && (!p.GetMethod.IsStatic) &&
+                                         (p.GetMethod == p.GetMethod.GetRuntimeBaseDefinition())
+                                         select p;
+            return nonStaticPropertyInfos.ToArray();
+#else
+            const BindingFlags attrs = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
+            var allProps = type.GetProperties(attrs).ToList();
+            var props = allProps.FindAll(p => p.GetGetMethod(true) != null && p.GetGetMethod(true) == p.GetGetMethod(true).GetBaseDefinition()).ToArray();
+            return props;
+#endif
+        }
+
+
+        public static FieldInfo[] GetAllFields(this Type type)
+        {
+#if NET45
+            FieldInfo[] fields= type.GetTypeInfo().DeclaredFields.ToArray();
+            var nonStaticFields = from field in fields
+                    where !field.IsStatic
+                    select field;
+            return nonStaticFields.ToArray();
+#else
+            var attrs = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
+            return type.GetFields(attrs);
+#endif
+        }
+
+        public static bool IsClass(this Type type)
+        {
+#if NET45
+            return type.GetTypeInfo().IsClass;
+#else
+            return type.IsClass;
+#endif
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentLoadException.cs b/MonoGame.Framework/Content/ContentLoadException.cs
new file mode 100644
index 00000000000..5d10b2e6692
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentLoadException.cs
@@ -0,0 +1,60 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    public class ContentLoadException : Exception
+    {
+        public ContentLoadException() : base()
+        {
+        }
+
+        public ContentLoadException(string message) : base(message)
+        {
+        }
+
+        public ContentLoadException(string message, Exception innerException) : base(message,innerException)
+        {
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Content/ContentManager.cs b/MonoGame.Framework/Content/ContentManager.cs
new file mode 100644
index 00000000000..76c6afef451
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentManager.cs
@@ -0,0 +1,510 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using MonoGame.Utilities;
+using Microsoft.Xna.Framework.Graphics;
+using System.Globalization;
+
+#if !WINDOWS_UAP
+using Microsoft.Xna.Framework.Audio;
+using Microsoft.Xna.Framework.Media;
+#endif
+
+namespace Microsoft.Xna.Framework.Content
+{
+	public partial class ContentManager : IDisposable
+	{
+        const byte ContentCompressedLzx = 0x80;
+        const byte ContentCompressedLz4 = 0x40;
+
+		private string _rootDirectory = string.Empty;
+		private IServiceProvider serviceProvider;
+		private IGraphicsDeviceService graphicsDeviceService;
+        private Dictionary<string, object> loadedAssets = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+		private List<IDisposable> disposableAssets = new List<IDisposable>();
+        private bool disposed;
+        private byte[] scratchBuffer;
+
+		private static object ContentManagerLock = new object();
+        private static List<WeakReference> ContentManagers = new List<WeakReference>();
+
+        private static readonly List<char> targetPlatformIdentifiers = new List<char>()
+        {
+            'w', // Windows (XNA & DirectX)
+            'x', // Xbox360 (XNA)
+            'm', // WindowsPhone7.0 (XNA)
+            'i', // iOS
+            'a', // Android
+            'd', // DesktopGL
+            'X', // MacOSX
+            'W', // WindowsStoreApp
+            'n', // NativeClient
+            'M', // WindowsPhone8
+            'r', // RaspberryPi
+            'P', // PlayStation4
+            'v', // PSVita
+            'O', // XboxOne
+            'S', // Nintendo Switch
+
+            // NOTE: There are additional idenfiers for consoles that 
+            // are not defined in this repository.  Be sure to ask the
+            // console port maintainers to ensure no collisions occur.
+
+            
+            // Legacy identifiers... these could be reused in the
+            // future if we feel enough time has passed.
+
+            'p', // PlayStationMobile
+            'g', // Windows (OpenGL)
+            'l', // Linux
+        };
+
+
+        static partial void PlatformStaticInit();
+
+        static ContentManager()
+        {
+            // Allow any per-platform static initialization to occur.
+            PlatformStaticInit();
+        }
+
+        private static void AddContentManager(ContentManager contentManager)
+        {
+            lock (ContentManagerLock)
+            {
+                // Check if the list contains this content manager already. Also take
+                // the opportunity to prune the list of any finalized content managers.
+                bool contains = false;
+                for (int i = ContentManagers.Count - 1; i >= 0; --i)
+                {
+                    var contentRef = ContentManagers[i];
+                    if (ReferenceEquals(contentRef.Target, contentManager))
+                        contains = true;
+                    if (!contentRef.IsAlive)
+                        ContentManagers.RemoveAt(i);
+                }
+                if (!contains)
+                    ContentManagers.Add(new WeakReference(contentManager));
+            }
+        }
+
+        private static void RemoveContentManager(ContentManager contentManager)
+        {
+            lock (ContentManagerLock)
+            {
+                // Check if the list contains this content manager and remove it. Also
+                // take the opportunity to prune the list of any finalized content managers.
+                for (int i = ContentManagers.Count - 1; i >= 0; --i)
+                {
+                    var contentRef = ContentManagers[i];
+                    if (!contentRef.IsAlive || ReferenceEquals(contentRef.Target, contentManager))
+                        ContentManagers.RemoveAt(i);
+                }
+            }
+        }
+
+        internal static void ReloadGraphicsContent()
+        {
+            lock (ContentManagerLock)
+            {
+                // Reload the graphic assets of each content manager. Also take the
+                // opportunity to prune the list of any finalized content managers.
+                for (int i = ContentManagers.Count - 1; i >= 0; --i)
+                {
+                    var contentRef = ContentManagers[i];
+                    if (contentRef.IsAlive)
+                    {
+                        var contentManager = (ContentManager)contentRef.Target;
+                        if (contentManager != null)
+                            contentManager.ReloadGraphicsAssets();
+                    }
+                    else
+                    {
+                        ContentManagers.RemoveAt(i);
+                    }
+                }
+            }
+        }
+
+		// Use C# destructor syntax for finalization code.
+		// This destructor will run only if the Dispose method
+		// does not get called.
+		// It gives your base class the opportunity to finalize.
+		// Do not provide destructors in types derived from this class.
+		~ContentManager()
+		{
+			// Do not re-create Dispose clean-up code here.
+			// Calling Dispose(false) is optimal in terms of
+			// readability and maintainability.
+			Dispose(false);
+		}
+
+		public ContentManager(IServiceProvider serviceProvider)
+		{
+			if (serviceProvider == null)
+			{
+				throw new ArgumentNullException("serviceProvider");
+			}
+			this.serviceProvider = serviceProvider;
+            AddContentManager(this);
+		}
+
+		public ContentManager(IServiceProvider serviceProvider, string rootDirectory)
+		{
+			if (serviceProvider == null)
+			{
+				throw new ArgumentNullException("serviceProvider");
+			}
+			if (rootDirectory == null)
+			{
+				throw new ArgumentNullException("rootDirectory");
+			}
+			this.RootDirectory = rootDirectory;
+			this.serviceProvider = serviceProvider;
+            AddContentManager(this);
+		}
+
+		public void Dispose()
+		{
+			Dispose(true);
+			// Tell the garbage collector not to call the finalizer
+			// since all the cleanup will already be done.
+			GC.SuppressFinalize(this);
+            // Once disposed, content manager wont be used again
+            RemoveContentManager(this);
+		}
+
+		// If disposing is true, it was called explicitly and we should dispose managed objects.
+		// If disposing is false, it was called by the finalizer and managed objects should not be disposed.
+		protected virtual void Dispose(bool disposing)
+		{
+			if (!disposed)
+			{
+                if (disposing)
+                {
+                    Unload();
+                }
+
+                scratchBuffer = null;
+				disposed = true;
+			}
+		}
+
+        public virtual T LoadLocalized<T> (string assetName)
+        {
+            string [] cultureNames =
+            {
+                CultureInfo.CurrentCulture.Name,                        // eg. "en-US"
+                CultureInfo.CurrentCulture.TwoLetterISOLanguageName     // eg. "en"
+            };
+
+            // Look first for a specialized language-country version of the asset,
+            // then if that fails, loop back around to see if we can find one that
+            // specifies just the language without the country part.
+            foreach (string cultureName in cultureNames) {
+                string localizedAssetName = assetName + '.' + cultureName;
+
+                try {
+                    return Load<T> (localizedAssetName);
+                } catch (ContentLoadException) { }
+            }
+
+            // If we didn't find any localized asset, fall back to the default name.
+            return Load<T> (assetName);
+        }
+
+		public virtual T Load<T>(string assetName)
+		{
+            if (string.IsNullOrEmpty(assetName))
+            {
+                throw new ArgumentNullException("assetName");
+            }
+            if (disposed)
+            {
+                throw new ObjectDisposedException("ContentManager");
+            }
+
+            T result = default(T);
+            
+            // On some platforms, name and slash direction matter.
+            // We store the asset by a /-seperating key rather than how the
+            // path to the file was passed to us to avoid
+            // loading "content/asset1.xnb" and "content\\ASSET1.xnb" as if they were two 
+            // different files. This matches stock XNA behavior.
+            // The dictionary will ignore case differences
+            var key = assetName.Replace('\\', '/');
+
+            // Check for a previously loaded asset first
+            object asset = null;
+            if (loadedAssets.TryGetValue(key, out asset))
+            {
+                if (asset is T)
+                {
+                    return (T)asset;
+                }
+            }
+
+            // Load the asset.
+            result = ReadAsset<T>(assetName, null);
+
+            loadedAssets[key] = result;
+            return result;
+		}
+		
+		protected virtual Stream OpenStream(string assetName)
+		{
+			Stream stream;
+			try
+            {
+                var assetPath = Path.Combine(RootDirectory, assetName) + ".xnb";
+
+                // This is primarily for editor support. 
+                // Setting the RootDirectory to an absolute path is useful in editor
+                // situations, but TitleContainer can ONLY be passed relative paths.                
+#if DESKTOPGL || WINDOWS
+                if (Path.IsPathRooted(assetPath))                
+                    stream = File.OpenRead(assetPath);                
+                else
+#endif                
+                stream = TitleContainer.OpenStream(assetPath);
+#if ANDROID
+                // Read the asset into memory in one go. This results in a ~50% reduction
+                // in load times on Android due to slow Android asset streams.
+                MemoryStream memStream = new MemoryStream();
+                stream.CopyTo(memStream);
+                memStream.Seek(0, SeekOrigin.Begin);
+                stream.Close();
+                stream = memStream;
+#endif
+			}
+			catch (FileNotFoundException fileNotFound)
+			{
+				throw new ContentLoadException("The content file was not found.", fileNotFound);
+			}
+#if !WINDOWS_UAP
+			catch (DirectoryNotFoundException directoryNotFound)
+			{
+				throw new ContentLoadException("The directory was not found.", directoryNotFound);
+			}
+#endif
+			catch (Exception exception)
+			{
+				throw new ContentLoadException("Opening stream error.", exception);
+			}
+			return stream;
+		}
+
+		protected T ReadAsset<T>(string assetName, Action<IDisposable> recordDisposableObject)
+		{
+			if (string.IsNullOrEmpty(assetName))
+			{
+				throw new ArgumentNullException("assetName");
+			}
+			if (disposed)
+			{
+				throw new ObjectDisposedException("ContentManager");
+			}
+						
+			string originalAssetName = assetName;
+			object result = null;
+
+			if (this.graphicsDeviceService == null)
+			{
+				this.graphicsDeviceService = serviceProvider.GetService(typeof(IGraphicsDeviceService)) as IGraphicsDeviceService;
+				if (this.graphicsDeviceService == null)
+				{
+					throw new InvalidOperationException("No Graphics Device Service");
+				}
+			}
+			
+            // Try to load as XNB file
+            var stream = OpenStream(assetName);
+            using (var xnbReader = new BinaryReader(stream))
+            {
+                using (var reader = GetContentReaderFromXnb(assetName, stream, xnbReader, recordDisposableObject))
+                {
+                    result = reader.ReadAsset<T>();
+                    if (result is GraphicsResource)
+                        ((GraphicsResource)result).Name = originalAssetName;
+                }
+            }
+            
+			if (result == null)
+				throw new ContentLoadException("Could not load " + originalAssetName + " asset!");
+
+			return (T)result;
+		}
+
+        private ContentReader GetContentReaderFromXnb(string originalAssetName, Stream stream, BinaryReader xnbReader, Action<IDisposable> recordDisposableObject)
+        {
+            // The first 4 bytes should be the "XNB" header. i use that to detect an invalid file
+            byte x = xnbReader.ReadByte();
+            byte n = xnbReader.ReadByte();
+            byte b = xnbReader.ReadByte();
+            byte platform = xnbReader.ReadByte();
+
+            if (x != 'X' || n != 'N' || b != 'B' ||
+                !(targetPlatformIdentifiers.Contains((char)platform)))
+            {
+                throw new ContentLoadException("Asset does not appear to be a valid XNB file. Did you process your content for Windows?");
+            }
+
+            byte version = xnbReader.ReadByte();
+            byte flags = xnbReader.ReadByte();
+
+            bool compressedLzx = (flags & ContentCompressedLzx) != 0;
+            bool compressedLz4 = (flags & ContentCompressedLz4) != 0;
+            if (version != 5 && version != 4)
+            {
+                throw new ContentLoadException("Invalid XNB version");
+            }
+
+            // The next int32 is the length of the XNB file
+            int xnbLength = xnbReader.ReadInt32();
+
+            Stream decompressedStream = null;
+            if (compressedLzx || compressedLz4)
+            {
+                // Decompress the xnb
+                int decompressedSize = xnbReader.ReadInt32();
+
+                if (compressedLzx)
+                {
+                    int compressedSize = xnbLength - 14;
+                    decompressedStream = new LzxDecoderStream(stream, decompressedSize, compressedSize);
+                }
+                else if (compressedLz4)
+                {
+                    decompressedStream = new Lz4DecoderStream(stream);
+                }
+            }
+            else
+            {
+                decompressedStream = stream;
+            }
+
+            var reader = new ContentReader(this, decompressedStream, this.graphicsDeviceService.GraphicsDevice,
+                                                        originalAssetName, version, recordDisposableObject);
+            
+            return reader;
+        }
+
+        internal void RecordDisposable(IDisposable disposable)
+        {
+            Debug.Assert(disposable != null, "The disposable is null!");
+
+            // Avoid recording disposable objects twice. ReloadAsset will try to record the disposables again.
+            // We don't know which asset recorded which disposable so just guard against storing multiple of the same instance.
+            if (!disposableAssets.Contains(disposable))
+                disposableAssets.Add(disposable);
+        }
+
+        /// <summary>
+        /// Virtual property to allow a derived ContentManager to have it's assets reloaded
+        /// </summary>
+        protected virtual Dictionary<string, object> LoadedAssets
+        {
+            get { return loadedAssets; }
+        }
+
+		protected virtual void ReloadGraphicsAssets()
+        {
+            foreach (var asset in LoadedAssets)
+            {
+                // This never executes as asset.Key is never null.  This just forces the 
+                // linker to include the ReloadAsset function when AOT compiled.
+                if (asset.Key == null)
+                    ReloadAsset(asset.Key, Convert.ChangeType(asset.Value, asset.Value.GetType()));
+
+                var methodInfo = ReflectionHelpers.GetMethodInfo(typeof(ContentManager), "ReloadAsset");
+                var genericMethod = methodInfo.MakeGenericMethod(asset.Value.GetType());
+                genericMethod.Invoke(this, new object[] { asset.Key, Convert.ChangeType(asset.Value, asset.Value.GetType()) }); 
+            }
+        }
+
+        protected virtual void ReloadAsset<T>(string originalAssetName, T currentAsset)
+        {
+			string assetName = originalAssetName;
+			if (string.IsNullOrEmpty(assetName))
+			{
+				throw new ArgumentNullException("assetName");
+			}
+			if (disposed)
+			{
+				throw new ObjectDisposedException("ContentManager");
+			}
+
+			if (this.graphicsDeviceService == null)
+			{
+				this.graphicsDeviceService = serviceProvider.GetService(typeof(IGraphicsDeviceService)) as IGraphicsDeviceService;
+				if (this.graphicsDeviceService == null)
+				{
+					throw new InvalidOperationException("No Graphics Device Service");
+				}
+			}
+
+            var stream = OpenStream(assetName);
+            using (var xnbReader = new BinaryReader(stream))
+            {
+                using (var reader = GetContentReaderFromXnb(assetName, stream, xnbReader, null))
+                {
+                    reader.ReadAsset<T>(currentAsset);
+                }
+            }
+		}
+
+		public virtual void Unload()
+		{
+		    // Look for disposable assets.
+		    foreach (var disposable in disposableAssets)
+		    {
+		        if (disposable != null)
+		            disposable.Dispose();
+		    }
+			disposableAssets.Clear();
+		    loadedAssets.Clear();
+		}
+
+		public string RootDirectory
+		{
+			get
+			{
+				return _rootDirectory;
+			}
+			set
+			{
+				_rootDirectory = value;
+			}
+		}
+
+        internal string RootDirectoryFullPath
+        {
+            get
+            {
+                return Path.Combine(TitleContainer.Location, RootDirectory);
+            }
+        }
+		
+		public IServiceProvider ServiceProvider
+		{
+			get
+			{
+				return this.serviceProvider;
+			}
+		}
+
+        internal byte[] GetScratchBuffer(int size)
+        {            
+            size = Math.Max(size, 1024 * 1024);
+            if (scratchBuffer == null || scratchBuffer.Length < size)
+                scratchBuffer = new byte[size];
+            return scratchBuffer;
+        }
+	}
+}
diff --git a/MonoGame.Framework/Content/ContentReader.cs b/MonoGame.Framework/Content/ContentReader.cs
new file mode 100644
index 00000000000..ced7817eadb
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReader.cs
@@ -0,0 +1,308 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Microsoft.Xna.Framework.Graphics;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    public sealed class ContentReader : BinaryReader
+    {
+        private ContentManager contentManager;
+        private Action<IDisposable> recordDisposableObject;
+        private ContentTypeReaderManager typeReaderManager;
+        private GraphicsDevice graphicsDevice;
+        private string assetName;
+        private List<KeyValuePair<int, Action<object>>> sharedResourceFixups;
+        private ContentTypeReader[] typeReaders;
+		internal int version;
+		internal int sharedResourceCount;
+
+        internal ContentTypeReader[] TypeReaders
+        {
+            get
+            {
+                return typeReaders;
+            }
+        }
+
+        internal GraphicsDevice GraphicsDevice
+        {
+            get
+            {
+                return this.graphicsDevice;
+            }
+        }
+
+        internal ContentReader(ContentManager manager, Stream stream, GraphicsDevice graphicsDevice, string assetName, int version, Action<IDisposable> recordDisposableObject)
+            : base(stream)
+        {
+            this.graphicsDevice = graphicsDevice;
+            this.recordDisposableObject = recordDisposableObject;
+            this.contentManager = manager;
+            this.assetName = assetName;
+			this.version = version;
+        }
+
+        public ContentManager ContentManager
+        {
+            get
+            {
+                return contentManager;
+            }
+        }
+        
+        public string AssetName
+        {
+            get
+            {
+                return assetName;
+            }
+        }
+
+        internal object ReadAsset<T>()
+        {
+            InitializeTypeReaders();
+
+            // Read primary object
+            object result = ReadObject<T>();
+
+            // Read shared resources
+            ReadSharedResources();
+            
+            return result;
+        }
+
+        internal object ReadAsset<T>(T existingInstance)
+        {
+            InitializeTypeReaders();
+
+            // Read primary object
+            object result = ReadObject<T>(existingInstance);
+
+            // Read shared resources
+            ReadSharedResources();
+
+            return result;
+        }
+
+        internal void InitializeTypeReaders()
+        {
+            typeReaderManager = new ContentTypeReaderManager();
+            typeReaders = typeReaderManager.LoadAssetReaders(this);
+            sharedResourceCount = Read7BitEncodedInt();
+            sharedResourceFixups = new List<KeyValuePair<int, Action<object>>>();
+        }
+
+        internal void ReadSharedResources()
+        {
+            if (sharedResourceCount <= 0)
+                return;
+
+            var sharedResources = new object[sharedResourceCount];
+            for (var i = 0; i < sharedResourceCount; ++i)
+                sharedResources[i] = InnerReadObject<object>(null);
+
+            // Fixup shared resources by calling each registered action
+            foreach (var fixup in sharedResourceFixups)
+                fixup.Value(sharedResources[fixup.Key]);
+        }
+
+        public T ReadExternalReference<T>()
+        {
+            var externalReference = ReadString();
+
+            if (!String.IsNullOrEmpty(externalReference))
+            {
+                return contentManager.Load<T>(FileHelpers.ResolveRelativePath(assetName, externalReference));
+            }
+
+            return default(T);
+        }
+
+        public Matrix ReadMatrix()
+        {
+            Matrix result = new Matrix();
+            result.M11 = ReadSingle();
+            result.M12 = ReadSingle();
+            result.M13 = ReadSingle();
+            result.M14 = ReadSingle(); 
+            result.M21 = ReadSingle();
+            result.M22 = ReadSingle();
+            result.M23 = ReadSingle();
+            result.M24 = ReadSingle();
+            result.M31 = ReadSingle();
+            result.M32 = ReadSingle();
+            result.M33 = ReadSingle();
+            result.M34 = ReadSingle();
+            result.M41 = ReadSingle();
+            result.M42 = ReadSingle();
+            result.M43 = ReadSingle();
+            result.M44 = ReadSingle();
+            return result;
+        }
+            
+        private void RecordDisposable<T>(T result)
+        {
+            var disposable = result as IDisposable;
+            if (disposable == null)
+                return;
+
+            if (recordDisposableObject != null)
+                recordDisposableObject(disposable);
+            else
+                contentManager.RecordDisposable(disposable);
+        }
+
+        public T ReadObject<T>()
+        {
+            return InnerReadObject(default(T));
+        }
+
+        public T ReadObject<T>(ContentTypeReader typeReader)
+        {
+            var result = (T)typeReader.Read(this, default(T));            
+            RecordDisposable(result);
+            return result;
+        }
+
+        public T ReadObject<T>(T existingInstance)
+        {
+            return InnerReadObject(existingInstance);
+        }
+
+        private T InnerReadObject<T>(T existingInstance)
+        {
+            var typeReaderIndex = Read7BitEncodedInt();
+            if (typeReaderIndex == 0)
+                return existingInstance;
+
+            if (typeReaderIndex > typeReaders.Length)
+                throw new ContentLoadException("Incorrect type reader index found!");
+
+            var typeReader = typeReaders[typeReaderIndex - 1];
+            var result = (T)typeReader.Read(this, existingInstance);
+
+            RecordDisposable(result);
+
+            return result;
+        }
+
+        public T ReadObject<T>(ContentTypeReader typeReader, T existingInstance)
+        {
+            if (!ReflectionHelpers.IsValueType(typeReader.TargetType))
+                return ReadObject(existingInstance);
+
+            var result = (T)typeReader.Read(this, existingInstance);
+
+            RecordDisposable(result);
+
+            return result;
+        }
+
+        public Quaternion ReadQuaternion()
+        {
+            Quaternion result = new Quaternion();
+            result.X = ReadSingle();
+            result.Y = ReadSingle();
+            result.Z = ReadSingle();
+            result.W = ReadSingle();
+            return result;
+        }
+
+        public T ReadRawObject<T>()
+        {
+			return (T)ReadRawObject<T> (default(T));
+        }
+
+        public T ReadRawObject<T>(ContentTypeReader typeReader)
+        {
+            return (T)ReadRawObject<T>(typeReader, default(T));
+        }
+
+        public T ReadRawObject<T>(T existingInstance)
+        {
+            Type objectType = typeof(T);
+            foreach(ContentTypeReader typeReader in typeReaders)
+            {
+                if(typeReader.TargetType == objectType)
+                    return (T)ReadRawObject<T>(typeReader,existingInstance);
+            }
+            throw new NotSupportedException();
+        }
+
+        public T ReadRawObject<T>(ContentTypeReader typeReader, T existingInstance)
+        {
+            return (T)typeReader.Read(this, existingInstance);
+        }
+
+        public void ReadSharedResource<T>(Action<T> fixup)
+        {
+            int index = Read7BitEncodedInt();
+            if (index > 0)
+            {
+                sharedResourceFixups.Add(new KeyValuePair<int, Action<object>>(index - 1, delegate(object v)
+                    {
+                        if (!(v is T))
+                        {
+                            throw new ContentLoadException(String.Format("Error loading shared resource. Expected type {0}, received type {1}", typeof(T).Name, v.GetType().Name));
+                        }
+                        fixup((T)v);
+                    }));
+            }
+        }
+
+        public Vector2 ReadVector2()
+        {
+            Vector2 result = new Vector2();
+            result.X = ReadSingle();
+            result.Y = ReadSingle();
+            return result;
+        }
+
+        public Vector3 ReadVector3()
+        {
+            Vector3 result = new Vector3();
+            result.X = ReadSingle();
+            result.Y = ReadSingle();
+            result.Z = ReadSingle();
+            return result;
+        }
+
+        public Vector4 ReadVector4()
+        {
+            Vector4 result = new Vector4();
+            result.X = ReadSingle();
+            result.Y = ReadSingle();
+            result.Z = ReadSingle();
+            result.W = ReadSingle();
+            return result;
+        }
+
+        public Color ReadColor()
+        {
+            Color result = new Color();
+            result.R = ReadByte();
+            result.G = ReadByte();
+            result.B = ReadByte();
+            result.A = ReadByte();
+            return result;
+        }
+
+        internal new int Read7BitEncodedInt()
+        {
+            return base.Read7BitEncodedInt();
+        }
+		
+		internal BoundingSphere ReadBoundingSphere()
+		{
+			var position = ReadVector3();
+            var radius = ReadSingle();
+            return new BoundingSphere(position, radius);
+		}
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/AlphaTestEffectReader.cs b/MonoGame.Framework/Content/ContentReaders/AlphaTestEffectReader.cs
new file mode 100644
index 00000000000..16fa4b28047
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/AlphaTestEffectReader.cs
@@ -0,0 +1,24 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    class AlphaTestEffectReader : ContentTypeReader<AlphaTestEffect>
+    {
+        protected internal override AlphaTestEffect Read(ContentReader input, AlphaTestEffect existingInstance)
+        {
+            var effect = new AlphaTestEffect(input.GraphicsDevice);
+
+            effect.Texture = input.ReadExternalReference<Texture>() as Texture2D;
+            effect.AlphaFunction = (CompareFunction)input.ReadInt32();
+            effect.ReferenceAlpha = (int)input.ReadUInt32();
+            effect.DiffuseColor = input.ReadVector3();
+            effect.Alpha = input.ReadSingle();
+            effect.VertexColorEnabled = input.ReadBoolean();
+            return effect;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/ArrayReader.cs b/MonoGame.Framework/Content/ContentReaders/ArrayReader.cs
new file mode 100644
index 00000000000..82f3ef42e06
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/ArrayReader.cs
@@ -0,0 +1,49 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class ArrayReader<T> : ContentTypeReader<T[]>
+    {
+        ContentTypeReader elementReader;
+
+        public ArrayReader()
+        {
+        }
+
+        protected internal override void Initialize(ContentTypeReaderManager manager)
+		{
+			Type readerType = typeof(T);
+			elementReader = manager.GetTypeReader(readerType);
+        }
+
+        protected internal override T[] Read(ContentReader input, T[] existingInstance)
+        {
+            uint count = input.ReadUInt32();
+            T[] array = existingInstance;
+            if (array == null)
+                array = new T[count];
+
+            if (ReflectionHelpers.IsValueType(typeof(T)))
+			{
+                for (uint i = 0; i < count; i++)
+                {
+                	array[i] = input.ReadObject<T>(elementReader);
+                }
+			}
+			else
+			{
+                for (uint i = 0; i < count; i++)
+                {
+                    var readerType = input.Read7BitEncodedInt();
+                	array[i] = readerType > 0 ? input.ReadObject<T>(input.TypeReaders[readerType - 1]) : default(T);
+                }
+			}
+            return array;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/BasicEffectReader.cs b/MonoGame.Framework/Content/ContentReaders/BasicEffectReader.cs
new file mode 100644
index 00000000000..ee1327454aa
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/BasicEffectReader.cs
@@ -0,0 +1,30 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class BasicEffectReader : ContentTypeReader<BasicEffect>
+    {
+        protected internal override BasicEffect Read(ContentReader input, BasicEffect existingInstance)
+        {
+            var effect = new BasicEffect(input.GraphicsDevice);
+            var texture = input.ReadExternalReference<Texture>() as Texture2D;
+            if (texture != null)
+            {
+                effect.Texture = texture;
+                effect.TextureEnabled = true;
+            }
+
+            effect.DiffuseColor = input.ReadVector3();
+            effect.EmissiveColor = input.ReadVector3();
+            effect.SpecularColor = input.ReadVector3();
+            effect.SpecularPower = input.ReadSingle();
+            effect.Alpha = input.ReadSingle();
+            effect.VertexColorEnabled = input.ReadBoolean();
+            return effect;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/BooleanReader.cs b/MonoGame.Framework/Content/ContentReaders/BooleanReader.cs
new file mode 100644
index 00000000000..1c409b18ef7
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/BooleanReader.cs
@@ -0,0 +1,25 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class BooleanReader : ContentTypeReader<bool>
+    {
+        public BooleanReader()
+        {
+        }
+
+        protected internal override bool Read(ContentReader input, bool existingInstance)
+        {
+            return input.ReadBoolean();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/BoundingBoxReader.cs b/MonoGame.Framework/Content/ContentReaders/BoundingBoxReader.cs
new file mode 100644
index 00000000000..befb6449e97
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/BoundingBoxReader.cs
@@ -0,0 +1,17 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Content
+{
+    class BoundingBoxReader : ContentTypeReader<BoundingBox>
+    {
+        protected internal override BoundingBox Read(ContentReader input, BoundingBox existingInstance)
+        {
+            var min = input.ReadVector3();
+            var max = input.ReadVector3();
+            var result = new BoundingBox(min, max);
+            return result;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/BoundingFrustumReader.cs b/MonoGame.Framework/Content/ContentReaders/BoundingFrustumReader.cs
new file mode 100644
index 00000000000..a48046d92b1
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/BoundingFrustumReader.cs
@@ -0,0 +1,21 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class BoundingFrustumReader : ContentTypeReader<BoundingFrustum>
+    {
+        public BoundingFrustumReader()
+        {
+        }
+
+        protected internal override BoundingFrustum Read(ContentReader input, BoundingFrustum existingInstance)
+        {
+            return new BoundingFrustum(input.ReadMatrix());
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/BoundingSphereReader.cs b/MonoGame.Framework/Content/ContentReaders/BoundingSphereReader.cs
new file mode 100644
index 00000000000..ed0845cb1cb
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/BoundingSphereReader.cs
@@ -0,0 +1,23 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class BoundingSphereReader : ContentTypeReader<BoundingSphere>
+    {
+        public BoundingSphereReader()
+        {
+        }
+
+        protected internal override BoundingSphere Read(ContentReader input, BoundingSphere existingInstance)
+        {
+            Vector3 center = input.ReadVector3();
+            float radius = input.ReadSingle();
+            return new BoundingSphere(center, radius);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/ByteReader.cs b/MonoGame.Framework/Content/ContentReaders/ByteReader.cs
new file mode 100644
index 00000000000..0ffb5cf94ad
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/ByteReader.cs
@@ -0,0 +1,20 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class ByteReader : ContentTypeReader<byte>
+    {
+        public ByteReader()
+        {
+        }
+
+        protected internal override byte Read(ContentReader input, byte existingInstance)
+        {
+            return input.ReadByte();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/CharReader.cs b/MonoGame.Framework/Content/ContentReaders/CharReader.cs
new file mode 100644
index 00000000000..12333c5732d
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/CharReader.cs
@@ -0,0 +1,25 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class CharReader : ContentTypeReader<char>
+    {
+        public CharReader()
+        {
+        }
+
+        protected internal override char Read(ContentReader input, char existingInstance)
+        {
+            return input.ReadChar();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/ColorReader.cs b/MonoGame.Framework/Content/ContentReaders/ColorReader.cs
new file mode 100644
index 00000000000..b29866a04d2
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/ColorReader.cs
@@ -0,0 +1,28 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class ColorReader : ContentTypeReader<Color>
+	{
+		public ColorReader ()
+		{
+		}
+
+		protected internal override Color Read (ContentReader input, Color existingInstance)
+		{
+            // Read RGBA as four separate bytes to make sure we comply with XNB format document
+            byte r = input.ReadByte();
+            byte g = input.ReadByte();
+            byte b = input.ReadByte();
+            byte a = input.ReadByte();
+            return new Color(r, g, b, a);
+		}
+	}
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/CurveReader.cs b/MonoGame.Framework/Content/ContentReaders/CurveReader.cs
new file mode 100644
index 00000000000..a6cc8077dee
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/CurveReader.cs
@@ -0,0 +1,36 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class CurveReader : ContentTypeReader<Curve>
+	{
+		protected internal override Curve Read(ContentReader input, Curve existingInstance)
+		{
+			Curve curve = existingInstance;
+			if (curve == null)
+			{
+				curve = new Curve();
+			}         
+			
+			curve.PreLoop = (CurveLoopType)input.ReadInt32();
+			curve.PostLoop = (CurveLoopType)input.ReadInt32();
+			int num6 = input.ReadInt32();
+			
+			for (int i = 0; i < num6; i++)
+			{
+				float position = input.ReadSingle();
+				float num4 = input.ReadSingle();
+				float tangentIn = input.ReadSingle();
+				float tangentOut = input.ReadSingle();
+				CurveContinuity continuity = (CurveContinuity)input.ReadInt32();
+				curve.Keys.Add(new CurveKey(position, num4, tangentIn, tangentOut, continuity));
+			}		
+			return curve;         
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Content/ContentReaders/DateTimeReader.cs b/MonoGame.Framework/Content/ContentReaders/DateTimeReader.cs
new file mode 100644
index 00000000000..65cf1de1213
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/DateTimeReader.cs
@@ -0,0 +1,24 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class DateTimeReader : ContentTypeReader<DateTime>
+    {
+        public DateTimeReader()
+        {
+        }
+
+        protected internal override DateTime Read(ContentReader input, DateTime existingInstance)
+        {
+            UInt64 value = input.ReadUInt64();
+            UInt64 mask = (UInt64)3 << 62;
+            long ticks = (long)(value & ~mask);
+            DateTimeKind kind = (DateTimeKind)((value >> 62) & 3);
+            return new DateTime(ticks, kind);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/DecimalReader.cs b/MonoGame.Framework/Content/ContentReaders/DecimalReader.cs
new file mode 100644
index 00000000000..e2160f9bae4
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/DecimalReader.cs
@@ -0,0 +1,20 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class DecimalReader : ContentTypeReader<decimal>
+    {
+        public DecimalReader()
+        {
+        }
+
+        protected internal override decimal Read(ContentReader input, decimal existingInstance)
+        {
+            return input.ReadDecimal();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/DictionaryReader.cs b/MonoGame.Framework/Content/ContentReaders/DictionaryReader.cs
new file mode 100644
index 00000000000..1a7f60a793f
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/DictionaryReader.cs
@@ -0,0 +1,78 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Content
+{
+
+    internal class DictionaryReader<TKey, TValue> : ContentTypeReader<Dictionary<TKey, TValue>>
+    {
+        ContentTypeReader keyReader;
+		ContentTypeReader valueReader;
+		
+		Type keyType;
+		Type valueType;
+		
+        public DictionaryReader()
+        {
+        }
+
+        protected internal override void Initialize(ContentTypeReaderManager manager)
+        {
+			keyType = typeof(TKey);
+			valueType = typeof(TValue);
+			
+			keyReader = manager.GetTypeReader(keyType);
+			valueReader = manager.GetTypeReader(valueType);
+        }
+
+        public override bool CanDeserializeIntoExistingObject
+        {
+            get { return true; }
+        }
+
+        protected internal override Dictionary<TKey, TValue> Read(ContentReader input, Dictionary<TKey, TValue> existingInstance)
+        {
+            int count = input.ReadInt32();
+            Dictionary<TKey, TValue> dictionary = existingInstance;
+            if (dictionary == null)
+                dictionary = new Dictionary<TKey, TValue>(count);
+            else
+                dictionary.Clear();
+
+            for (int i = 0; i < count; i++)
+            {
+				TKey key;
+				TValue value;
+
+                if (ReflectionHelpers.IsValueType(keyType))
+                {
+                	key = input.ReadObject<TKey>(keyReader);
+				}
+				else
+                {
+                    var readerType = input.Read7BitEncodedInt();
+                    key = readerType > 0 ? input.ReadObject<TKey>(input.TypeReaders[readerType - 1]) : default(TKey);
+                }
+
+                if (ReflectionHelpers.IsValueType(valueType))
+				{
+                	value = input.ReadObject<TValue>(valueReader);
+				}
+				else
+                {
+                    var readerType = input.Read7BitEncodedInt();
+                    value = readerType > 0 ? input.ReadObject<TValue>(input.TypeReaders[readerType - 1]) : default(TValue);
+                }
+
+                dictionary.Add(key, value);
+            }
+            return dictionary;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Content/ContentReaders/DoubleReader.cs b/MonoGame.Framework/Content/ContentReaders/DoubleReader.cs
new file mode 100644
index 00000000000..cd89b5d126c
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/DoubleReader.cs
@@ -0,0 +1,21 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class DoubleReader : ContentTypeReader<double>
+    {
+        public DoubleReader()
+        {
+        }
+
+        protected internal override double Read(ContentReader input, double existingInstance)
+        {
+            return input.ReadDouble();
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Content/ContentReaders/DualTextureEffectReader.cs b/MonoGame.Framework/Content/ContentReaders/DualTextureEffectReader.cs
new file mode 100644
index 00000000000..c17f89694cb
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/DualTextureEffectReader.cs
@@ -0,0 +1,25 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    class DualTextureEffectReader : ContentTypeReader<DualTextureEffect>
+    {
+        protected internal override DualTextureEffect Read(ContentReader input, DualTextureEffect existingInstance)
+        {
+			DualTextureEffect effect = new DualTextureEffect(input.GraphicsDevice);
+			effect.Texture = input.ReadExternalReference<Texture>() as Texture2D;
+			effect.Texture2 = input.ReadExternalReference<Texture>() as Texture2D;
+			effect.DiffuseColor = input.ReadVector3 ();
+			effect.Alpha = input.ReadSingle ();
+			effect.VertexColorEnabled = input.ReadBoolean ();
+			return effect;
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Content/ContentReaders/EffectMaterialReader.cs b/MonoGame.Framework/Content/ContentReaders/EffectMaterialReader.cs
new file mode 100644
index 00000000000..3c84a91ec4d
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/EffectMaterialReader.cs
@@ -0,0 +1,81 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using Microsoft.Xna.Framework.Graphics;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class EffectMaterialReader : ContentTypeReader<EffectMaterial>
+	{
+		protected internal override EffectMaterial Read (ContentReader input, EffectMaterial existingInstance)
+		{
+			var effect = input.ReadExternalReference<Effect> ();
+			var effectMaterial = new EffectMaterial (effect);
+
+			var dict = input.ReadObject<Dictionary<string, object>> ();
+
+			foreach (KeyValuePair<string, object> item in dict) {
+				var parameter = effectMaterial.Parameters [item.Key];
+				if (parameter != null) {
+
+					Type itemType = item.Value.GetType();
+
+					if (ReflectionHelpers.IsAssignableFromType(typeof(Texture), itemType)) {
+						parameter.SetValue ((Texture)item.Value);
+					}
+					else if (ReflectionHelpers.IsAssignableFromType(typeof(int), itemType)) {
+						parameter.SetValue((int) item.Value);
+					}
+					else if (ReflectionHelpers.IsAssignableFromType(typeof(bool), itemType)) {
+						parameter.SetValue((bool) item.Value);
+					}
+					else if (ReflectionHelpers.IsAssignableFromType(typeof(float), itemType)) {
+						parameter.SetValue((float) item.Value);
+					}
+					else if (ReflectionHelpers.IsAssignableFromType(typeof(float []), itemType)) {
+						parameter.SetValue((float[]) item.Value);
+					}
+					else if (ReflectionHelpers.IsAssignableFromType(typeof(Vector2), itemType)) {
+						parameter.SetValue((Vector2) item.Value);
+					}
+					else if (ReflectionHelpers.IsAssignableFromType(typeof(Vector2 []), itemType)) {
+						parameter.SetValue((Vector2 []) item.Value);
+					}
+					else if (ReflectionHelpers.IsAssignableFromType(typeof(Vector3), itemType)) {
+						parameter.SetValue((Vector3) item.Value);
+					}
+					else if (ReflectionHelpers.IsAssignableFromType(typeof(Vector3 []), itemType)) {
+						parameter.SetValue((Vector3 []) item.Value);
+					}
+					else if (ReflectionHelpers.IsAssignableFromType(typeof(Vector4), itemType)) {
+						parameter.SetValue((Vector4) item.Value);
+					}
+					else if (ReflectionHelpers.IsAssignableFromType(typeof(Vector4 []), itemType)) {
+						parameter.SetValue((Vector4 []) item.Value);
+					}
+					else if (ReflectionHelpers.IsAssignableFromType(typeof(Matrix), itemType)) {
+						parameter.SetValue((Matrix) item.Value);
+					}
+					else if (ReflectionHelpers.IsAssignableFromType(typeof(Matrix []), itemType)) {
+						parameter.SetValue((Matrix[]) item.Value);
+					}
+					else if (ReflectionHelpers.IsAssignableFromType(typeof(Quaternion), itemType)) {
+						parameter.SetValue((Quaternion) item.Value);
+					}
+					else {
+						throw new NotSupportedException ("Parameter type is not supported");
+					}
+				} else {
+					Debug.WriteLine ("No parameter " + item.Key);
+				}
+			}
+
+			return effectMaterial;
+		}
+	}
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/EffectReader.cs b/MonoGame.Framework/Content/ContentReaders/EffectReader.cs
new file mode 100644
index 00000000000..ef295c65c4f
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/EffectReader.cs
@@ -0,0 +1,25 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class EffectReader : ContentTypeReader<Effect>
+    {
+        public EffectReader()
+        {
+        }
+
+        protected internal override Effect Read(ContentReader input, Effect existingInstance)
+        {
+            int dataSize = input.ReadInt32();
+            byte[] data = input.ContentManager.GetScratchBuffer(dataSize);
+            input.Read(data, 0, dataSize);
+            var effect = new Effect(input.GraphicsDevice, data, 0, dataSize);
+            effect.Name = input.AssetName;
+            return effect;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/EnumReader.cs b/MonoGame.Framework/Content/ContentReaders/EnumReader.cs
new file mode 100644
index 00000000000..ca7f91454dd
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/EnumReader.cs
@@ -0,0 +1,29 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class EnumReader<T> : ContentTypeReader<T>
+    {
+        ContentTypeReader elementReader;
+
+        public EnumReader()
+        {
+        }
+
+        protected internal override void Initialize(ContentTypeReaderManager manager)
+        {			
+			Type readerType = Enum.GetUnderlyingType(typeof(T));
+			elementReader = manager.GetTypeReader(readerType);
+        }
+		
+        protected internal override T Read(ContentReader input, T existingInstance)
+        {
+			return input.ReadRawObject<T>(elementReader);
+		}
+    }
+}
+
diff --git a/MonoGame.Framework/Content/ContentReaders/EnvironmentMapEffectReader.cs b/MonoGame.Framework/Content/ContentReaders/EnvironmentMapEffectReader.cs
new file mode 100644
index 00000000000..d7175cc68c6
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/EnvironmentMapEffectReader.cs
@@ -0,0 +1,26 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    class EnvironmentMapEffectReader : ContentTypeReader<EnvironmentMapEffect>
+    {
+        protected internal override EnvironmentMapEffect Read(ContentReader input, EnvironmentMapEffect existingInstance)
+        {
+            var effect = new EnvironmentMapEffect(input.GraphicsDevice);
+            effect.Texture = input.ReadExternalReference<Texture>() as Texture2D;
+			effect.EnvironmentMap = input.ReadExternalReference<TextureCube>() as TextureCube;
+			effect.EnvironmentMapAmount = input.ReadSingle ();
+			effect.EnvironmentMapSpecular = input.ReadVector3 ();
+			effect.FresnelFactor = input.ReadSingle ();
+			effect.DiffuseColor = input.ReadVector3 ();
+			effect.EmissiveColor = input.ReadVector3 ();
+			effect.Alpha = input.ReadSingle ();
+            return effect;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/ExternalReferenceReader.cs b/MonoGame.Framework/Content/ContentReaders/ExternalReferenceReader.cs
new file mode 100644
index 00000000000..68b8224d9fd
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/ExternalReferenceReader.cs
@@ -0,0 +1,23 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Content
+{
+    /// <summary>
+    /// External reference reader, provided for compatibility with XNA Framework built content
+    /// </summary>
+    internal class ExternalReferenceReader : ContentTypeReader
+    {
+        public ExternalReferenceReader()
+            : base(null)
+        {
+
+        }
+
+        protected internal override object Read(ContentReader input, object existingInstance)
+        {
+            return input.ReadExternalReference<object>();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/IndexBufferReader.cs b/MonoGame.Framework/Content/ContentReaders/IndexBufferReader.cs
new file mode 100644
index 00000000000..f5c8b21d9a1
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/IndexBufferReader.cs
@@ -0,0 +1,31 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    class IndexBufferReader : ContentTypeReader<IndexBuffer>
+    {
+        protected internal override IndexBuffer Read(ContentReader input, IndexBuffer existingInstance)
+        {
+            IndexBuffer indexBuffer = existingInstance;
+
+            bool sixteenBits = input.ReadBoolean();
+            int dataSize = input.ReadInt32();
+            byte[] data = input.ContentManager.GetScratchBuffer(dataSize);
+            input.Read(data, 0, dataSize);
+
+            if (indexBuffer == null)
+            {
+                indexBuffer = new IndexBuffer(input.GraphicsDevice,
+                    sixteenBits ? IndexElementSize.SixteenBits : IndexElementSize.ThirtyTwoBits, 
+                    dataSize / (sixteenBits ? 2 : 4), BufferUsage.None);
+            }
+
+            indexBuffer.SetData(data, 0, dataSize);
+            return indexBuffer;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/Int16Reader.cs b/MonoGame.Framework/Content/ContentReaders/Int16Reader.cs
new file mode 100644
index 00000000000..d6fce01deb9
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/Int16Reader.cs
@@ -0,0 +1,22 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+using Microsoft.Xna.Framework.Content;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class Int16Reader : ContentTypeReader<short>
+	{
+		public Int16Reader ()
+		{
+		}
+
+		protected internal override short Read (ContentReader input, short existingInstance)
+		{
+			return input.ReadInt16 ();
+		}
+	}
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/Int32Reader.cs b/MonoGame.Framework/Content/ContentReaders/Int32Reader.cs
new file mode 100644
index 00000000000..edaa846731a
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/Int32Reader.cs
@@ -0,0 +1,20 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class Int32Reader : ContentTypeReader<int>
+    {
+        public Int32Reader()
+        {
+        }
+
+        protected internal override int Read(ContentReader input, int existingInstance)
+        {
+            return input.ReadInt32();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/Int64Reader.cs b/MonoGame.Framework/Content/ContentReaders/Int64Reader.cs
new file mode 100644
index 00000000000..3b2bb1135e3
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/Int64Reader.cs
@@ -0,0 +1,22 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+using Microsoft.Xna.Framework.Content;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class Int64Reader : ContentTypeReader<long>
+	{
+		public Int64Reader ()
+		{
+		}
+
+		protected internal override long Read (ContentReader input, long existingInstance)
+		{
+			return input.ReadInt64 ();
+		}
+	}
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/ListReader.cs b/MonoGame.Framework/Content/ContentReaders/ListReader.cs
new file mode 100644
index 00000000000..7293691d2c1
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/ListReader.cs
@@ -0,0 +1,51 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework.Content;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class ListReader<T> : ContentTypeReader<List<T>>
+    {
+        ContentTypeReader elementReader;
+
+        public ListReader()
+        {
+        }
+
+        protected internal override void Initialize(ContentTypeReaderManager manager)
+        {
+			Type readerType = typeof(T);
+			elementReader = manager.GetTypeReader(readerType);
+        }
+
+        public override bool CanDeserializeIntoExistingObject
+        {
+            get { return true; }
+        }
+
+        protected internal override List<T> Read(ContentReader input, List<T> existingInstance)
+        {
+            int count = input.ReadInt32();
+            List<T> list = existingInstance;
+            if (list == null) list = new List<T>(count);
+            for (int i = 0; i < count; i++)
+            {
+                if (ReflectionHelpers.IsValueType(typeof(T)))
+				{
+                	list.Add(input.ReadObject<T>(elementReader));
+				}
+				else
+				{
+                    var readerType = input.Read7BitEncodedInt();
+                	list.Add(readerType > 0 ? input.ReadObject<T>(input.TypeReaders[readerType - 1]) : default(T));
+				}
+            }
+            return list;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/MatrixReader.cs b/MonoGame.Framework/Content/ContentReaders/MatrixReader.cs
new file mode 100644
index 00000000000..54659e79b73
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/MatrixReader.cs
@@ -0,0 +1,30 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Content
+{
+    class MatrixReader : ContentTypeReader<Matrix>
+    {
+        protected internal override Matrix Read(ContentReader input, Matrix existingInstance)
+        {
+            var m11 = input.ReadSingle();
+            var m12 = input.ReadSingle();
+            var m13 = input.ReadSingle();
+            var m14 = input.ReadSingle();
+            var m21 = input.ReadSingle();
+            var m22 = input.ReadSingle();
+            var m23 = input.ReadSingle();
+            var m24 = input.ReadSingle();
+            var m31 = input.ReadSingle();
+            var m32 = input.ReadSingle();
+            var m33 = input.ReadSingle();
+            var m34 = input.ReadSingle();
+            var m41 = input.ReadSingle();
+            var m42 = input.ReadSingle();
+            var m43 = input.ReadSingle();
+            var m44 = input.ReadSingle();
+            return new Matrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/ModelReader.cs b/MonoGame.Framework/Content/ContentReaders/ModelReader.cs
new file mode 100644
index 00000000000..3441826259c
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/ModelReader.cs
@@ -0,0 +1,199 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Content;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class ModelReader : ContentTypeReader<Model>
+	{
+//      List<VertexBuffer> vertexBuffers = new List<VertexBuffer>();
+//      List<IndexBuffer> indexBuffers = new List<IndexBuffer>();
+//      List<Effect> effects = new List<Effect>();
+//      List<GraphicsResource> sharedResources = new List<GraphicsResource>();
+
+		public ModelReader ()
+		{
+		}
+		
+		static int ReadBoneReference(ContentReader reader, uint boneCount)
+        {
+            uint boneId;
+
+            // Read the bone ID, which may be encoded as either an 8 or 32 bit value.
+            if (boneCount < 255)
+            {
+                boneId = reader.ReadByte();
+            }
+            else
+            {
+                boneId = reader.ReadUInt32();
+            }
+
+            // Print out the bone ID.
+            if (boneId != 0)
+            {
+                //Debug.WriteLine("bone #{0}", boneId - 1);
+                return (int)(boneId - 1);
+            }
+            else
+            {
+                //Debug.WriteLine("null");
+            }
+
+            return -1;
+        }
+		
+		protected internal override Model Read(ContentReader reader, Model existingInstance)
+		{
+            // Read the bone names and transforms.
+            uint boneCount = reader.ReadUInt32();
+            //Debug.WriteLine("Bone count: {0}", boneCount);
+
+            List<ModelBone> bones = new List<ModelBone>((int)boneCount);
+
+            for (uint i = 0; i < boneCount; i++)
+            {
+                string name = reader.ReadObject<string>();
+				var matrix = reader.ReadMatrix();
+                var bone = new ModelBone { Transform = matrix, Index = (int)i, Name = name };
+                bones.Add(bone);
+            }
+			
+            // Read the bone hierarchy.
+            for (int i = 0; i < boneCount; i++)
+            {
+                var bone = bones[i];
+
+                //Debug.WriteLine("Bone {0} hierarchy:", i);
+
+                // Read the parent bone reference.
+                //Debug.WriteLine("Parent: ");
+                var parentIndex = ReadBoneReference(reader, boneCount);
+
+                if (parentIndex != -1)
+                {
+                    bone.Parent = bones[parentIndex];
+                }
+
+                // Read the child bone references.
+                uint childCount = reader.ReadUInt32();
+
+                if (childCount != 0)
+                {
+                    //Debug.WriteLine("Children:");
+
+                    for (uint j = 0; j < childCount; j++)
+                    {
+                        var childIndex = ReadBoneReference(reader, boneCount);
+                        if (childIndex != -1)
+                        {
+                            bone.AddChild(bones[childIndex]);
+                        }
+                    }
+                }
+            }
+
+            List<ModelMesh> meshes = new List<ModelMesh>();
+
+            //// Read the mesh data.
+            int meshCount = reader.ReadInt32();
+            //Debug.WriteLine("Mesh count: {0}", meshCount);
+
+            for (int i = 0; i < meshCount; i++)
+            {
+
+                //Debug.WriteLine("Mesh {0}", i);
+                string name = reader.ReadObject<string>();
+                var parentBoneIndex = ReadBoneReference(reader, boneCount);
+				var boundingSphere = reader.ReadBoundingSphere();
+
+                // Tag
+                var meshTag = reader.ReadObject<object>();
+
+                // Read the mesh part data.
+                int partCount = reader.ReadInt32();
+                //Debug.WriteLine("Mesh part count: {0}", partCount);
+
+                List<ModelMeshPart> parts = new List<ModelMeshPart>(partCount);
+
+                for (uint j = 0; j < partCount; j++)
+                {
+                    ModelMeshPart part;
+                    if (existingInstance != null)
+                        part = existingInstance.Meshes[i].MeshParts[(int)j];
+                    else
+                        part = new ModelMeshPart();
+
+					part.VertexOffset = reader.ReadInt32();
+                    part.NumVertices = reader.ReadInt32();
+                    part.StartIndex = reader.ReadInt32();
+                    part.PrimitiveCount = reader.ReadInt32();
+
+                    // tag
+                    part.Tag = reader.ReadObject<object>();
+					
+					parts.Add(part);
+					
+					int jj = (int)j;
+					reader.ReadSharedResource<VertexBuffer>(delegate (VertexBuffer v)
+					{
+						parts[jj].VertexBuffer = v;
+					});
+					reader.ReadSharedResource<IndexBuffer>(delegate (IndexBuffer v)
+					{
+						parts[jj].IndexBuffer = v;
+					});
+					reader.ReadSharedResource<Effect>(delegate (Effect v)
+					{
+						parts[jj].Effect = v;
+					});
+
+					
+                }
+
+                if (existingInstance != null)
+                    continue;
+
+				ModelMesh mesh = new ModelMesh(reader.GraphicsDevice, parts);
+
+                // Tag reassignment
+                mesh.Tag = meshTag;
+
+				mesh.Name = name;
+				mesh.ParentBone = bones[parentBoneIndex];
+				mesh.ParentBone.AddMesh(mesh);
+				mesh.BoundingSphere = boundingSphere;
+				meshes.Add(mesh);
+            }
+
+            if (existingInstance != null)
+            {
+                // Read past remaining data and return existing instance
+                ReadBoneReference(reader, boneCount);
+                reader.ReadObject<object>();
+                return existingInstance;
+            }
+
+            // Read the final pieces of model data.
+            var rootBoneIndex = ReadBoneReference(reader, boneCount);
+
+            Model model = new Model(reader.GraphicsDevice, bones, meshes);
+
+            model.Root = bones[rootBoneIndex];
+		
+			model.BuildHierarchy();
+			
+			// Tag?
+            model.Tag = reader.ReadObject<object>();
+			
+			return model;
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Content/ContentReaders/MultiArrayReader.cs b/MonoGame.Framework/Content/ContentReaders/MultiArrayReader.cs
new file mode 100644
index 00000000000..9661a0d266f
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/MultiArrayReader.cs
@@ -0,0 +1,83 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class MultiArrayReader<T> : ContentTypeReader<Array>
+    {
+        ContentTypeReader elementReader;
+
+        public MultiArrayReader() { }
+
+        protected internal override void Initialize(ContentTypeReaderManager manager)
+        {
+            Type readerType = typeof(T);
+            elementReader = manager.GetTypeReader(readerType);
+        }
+
+        protected internal override Array Read(ContentReader input, Array existingInstance)
+        {
+            var rank = input.ReadInt32();
+            if (rank < 1)
+                throw new RankException();
+
+            var dimensions = new int[rank];
+            var count = 1;
+            for (int d = 0; d < dimensions.Length; d++)
+                count *= dimensions[d] = input.ReadInt32();
+
+
+            var array = existingInstance;
+            if (array == null)
+                array = Array.CreateInstance(typeof(T), dimensions);//new T[count];
+            else if (dimensions.Length != array.Rank)
+                throw new RankException("existingInstance");
+
+            var indices = new int[rank];
+
+            for (int i = 0; i < count; i++)
+            {
+                T value;
+                if (ReflectionHelpers.IsValueType(typeof(T)))
+                    value = input.ReadObject<T>(elementReader);
+                else
+                {
+                    var readerType = input.Read7BitEncodedInt();
+                    if (readerType > 0)
+                        value = input.ReadObject<T>(input.TypeReaders[readerType - 1]);
+                    else
+                        value = default(T);
+                }
+
+                CalcIndices(array, i, indices);
+                array.SetValue(value, indices);
+            }
+
+            return array;
+        }
+
+        static void CalcIndices(Array array, int index, int[] indices)
+        {
+            if (array.Rank != indices.Length)
+                throw new Exception("indices");
+
+            for (int d = 0; d < indices.Length; d++)
+            {
+                if (index == 0)
+                    indices[d] = 0;
+                else
+                {
+                    indices[d] = index % array.GetLength(d);
+                    index /= array.GetLength(d);
+                }
+            }
+
+            if (index != 0)
+                throw new ArgumentOutOfRangeException("index");
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/NullableReader.cs b/MonoGame.Framework/Content/ContentReaders/NullableReader.cs
new file mode 100644
index 00000000000..dd2ffff90c6
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/NullableReader.cs
@@ -0,0 +1,32 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class NullableReader<T> : ContentTypeReader<T?> where T : struct
+    {
+        ContentTypeReader elementReader;
+
+        public NullableReader()
+        {
+        }
+
+        protected internal override void Initialize(ContentTypeReaderManager manager)
+        {			
+			Type readerType = typeof(T);
+			elementReader = manager.GetTypeReader(readerType);
+        }
+		
+        protected internal override T? Read(ContentReader input, T? existingInstance)
+        {
+			if(input.ReadBoolean())
+				return input.ReadObject<T>(elementReader);
+			
+			return null;
+		}
+    }
+}
+
diff --git a/MonoGame.Framework/Content/ContentReaders/PlaneReader.cs b/MonoGame.Framework/Content/ContentReaders/PlaneReader.cs
new file mode 100644
index 00000000000..d901edd0e6c
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/PlaneReader.cs
@@ -0,0 +1,22 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class PlaneReader : ContentTypeReader<Plane>
+    {
+        public PlaneReader()
+        {
+        }
+
+        protected internal override Plane Read(ContentReader input, Plane existingInstance)
+        {
+            existingInstance.Normal = input.ReadVector3();
+            existingInstance.D = input.ReadSingle();
+            return existingInstance;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/PointReader.cs b/MonoGame.Framework/Content/ContentReaders/PointReader.cs
new file mode 100644
index 00000000000..fde2a0cbd58
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/PointReader.cs
@@ -0,0 +1,27 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class PointReader : ContentTypeReader<Point>
+	{
+		public PointReader ()
+			{
+		}
+
+		protected internal override Point Read (ContentReader input, Point existingInstance)
+		{
+			int X = input.ReadInt32 ();
+			int Y = input.ReadInt32 ();
+			return new Point ( X, Y);
+		}
+	}
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/QuaternionReader.cs b/MonoGame.Framework/Content/ContentReaders/QuaternionReader.cs
new file mode 100644
index 00000000000..4479d14e186
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/QuaternionReader.cs
@@ -0,0 +1,20 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class QuaternionReader : ContentTypeReader<Quaternion>
+    {
+        public QuaternionReader()
+        {
+        }
+
+        protected internal override Quaternion Read(ContentReader input, Quaternion existingInstance)
+        {
+            return input.ReadQuaternion();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/RayReader.cs b/MonoGame.Framework/Content/ContentReaders/RayReader.cs
new file mode 100644
index 00000000000..c7e0020c20f
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/RayReader.cs
@@ -0,0 +1,23 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class RayReader : ContentTypeReader<Ray>
+    {
+        public RayReader()
+        {
+        }
+
+        protected internal override Ray Read(ContentReader input, Ray existingInstance)
+        {
+            Vector3 position = input.ReadVector3();
+            Vector3 direction = input.ReadVector3();
+            return new Ray(position, direction);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/RectangleReader.cs b/MonoGame.Framework/Content/ContentReaders/RectangleReader.cs
new file mode 100644
index 00000000000..a09c4c36044
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/RectangleReader.cs
@@ -0,0 +1,30 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	
+	internal class RectangleReader : ContentTypeReader<Rectangle>
+    {
+        public RectangleReader()
+        {
+        }
+
+        protected internal override Rectangle Read(ContentReader input, Rectangle existingInstance)
+        {
+            int left = input.ReadInt32();
+            int top = input.ReadInt32();
+            int width = input.ReadInt32();
+            int height = input.ReadInt32();
+            return new Rectangle(left, top, width, height);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/ReflectiveReader.cs b/MonoGame.Framework/Content/ContentReaders/ReflectiveReader.cs
new file mode 100755
index 00000000000..6170463756c
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/ReflectiveReader.cs
@@ -0,0 +1,191 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class ReflectiveReader<T> : ContentTypeReader
+    {
+        delegate void ReadElement(ContentReader input, object parent);
+
+        private List<ReadElement> _readers;
+
+        private ConstructorInfo _constructor;
+
+        private ContentTypeReader _baseTypeReader;
+
+
+        public ReflectiveReader() 
+            : base(typeof(T))
+        {
+        }
+
+        public override bool CanDeserializeIntoExistingObject
+        {
+            get { return TargetType.IsClass(); }
+        }
+
+        protected internal override void Initialize(ContentTypeReaderManager manager)
+        {
+            base.Initialize(manager);
+
+            var baseType = ReflectionHelpers.GetBaseType(TargetType);
+            if (baseType != null && baseType != typeof(object))
+				_baseTypeReader = manager.GetTypeReader(baseType);
+
+            _constructor = TargetType.GetDefaultConstructor();
+
+            var properties = TargetType.GetAllProperties();
+            var fields = TargetType.GetAllFields();
+            _readers = new List<ReadElement>(fields.Length + properties.Length);
+
+            // Gather the properties.
+            foreach (var property in properties)
+            {
+                var read = GetElementReader(manager, property);
+                if (read != null)
+                    _readers.Add(read);
+            }
+            
+            // Gather the fields.
+            foreach (var field in fields)
+            {
+                var read = GetElementReader(manager, field);
+                if (read != null)
+                    _readers.Add(read);
+            }
+        }
+
+        private static ReadElement GetElementReader(ContentTypeReaderManager manager, MemberInfo member)
+        {
+            var property = member as PropertyInfo;
+            var field = member as FieldInfo;
+            Debug.Assert(field != null || property != null);
+
+            if (property != null)
+            {
+                // Properties must have at least a getter.
+                if (property.CanRead == false)
+                    return null;
+
+                // Skip over indexer properties.
+                if (property.GetIndexParameters().Any())
+                    return null;
+            }
+
+            // Are we explicitly asked to ignore this item?
+            if (ReflectionHelpers.GetCustomAttribute<ContentSerializerIgnoreAttribute>(member) != null) 
+                return null;
+
+            var contentSerializerAttribute = ReflectionHelpers.GetCustomAttribute<ContentSerializerAttribute>(member);
+            if (contentSerializerAttribute == null)
+            {
+                if (property != null)
+                {
+                    // There is no ContentSerializerAttribute, so non-public
+                    // properties cannot be deserialized.
+                    if (!ReflectionHelpers.PropertyIsPublic(property))
+                        return null;
+
+                    // If the read-only property has a type reader,
+                    // and CanDeserializeIntoExistingObject is true,
+                    // then it is safe to deserialize into the existing object.
+                    if (!property.CanWrite)
+                    {
+                        var typeReader = manager.GetTypeReader(property.PropertyType);
+                        if (typeReader == null || !typeReader.CanDeserializeIntoExistingObject)
+                            return null;
+                    }
+                }
+                else
+                {
+                    // There is no ContentSerializerAttribute, so non-public
+                    // fields cannot be deserialized.
+                    if (!field.IsPublic)
+                        return null;
+
+                    // evolutional: Added check to skip initialise only fields
+                    if (field.IsInitOnly)
+                        return null;
+                }
+            }
+
+            Action<object, object> setter;
+            Type elementType;
+            if (property != null)
+            {
+                elementType = property.PropertyType;
+                if (property.CanWrite)
+                    setter = (o, v) => property.SetValue(o, v, null);
+                else
+                    setter = (o, v) => { };
+            }
+            else
+            {
+                elementType = field.FieldType;
+                setter = field.SetValue;
+            }
+
+            // Shared resources get special treatment.
+            if (contentSerializerAttribute != null && contentSerializerAttribute.SharedResource)
+            {
+                return (input, parent) =>
+                {
+                    Action<object> action = value => setter(parent, value);
+                    input.ReadSharedResource(action);
+                };
+            }
+
+            // We need to have a reader at this point.
+            var reader = manager.GetTypeReader(elementType);
+            if (reader == null)
+                if (elementType == typeof(System.Array))
+                    reader = new ArrayReader<Array>();
+                else
+                    throw new ContentLoadException(string.Format("Content reader could not be found for {0} type.", elementType.FullName));
+
+            // We use the construct delegate to pick the correct existing 
+            // object to be the target of deserialization.
+            Func<object, object> construct = parent => null;
+            if (property != null && !property.CanWrite)
+                construct = parent => property.GetValue(parent, null);
+
+            return (input, parent) =>
+            {
+                var existing = construct(parent);
+                var obj2 = input.ReadObject(reader, existing);
+                setter(parent, obj2);
+            };
+        }
+      
+        protected internal override object Read(ContentReader input, object existingInstance)
+        {
+            T obj;
+            if (existingInstance != null)
+                obj = (T)existingInstance;
+            else
+                obj = (_constructor == null ? (T)Activator.CreateInstance(typeof(T)) : (T)_constructor.Invoke(null));
+		
+			if(_baseTypeReader != null)
+				_baseTypeReader.Read(input, obj);
+
+            // Box the type.
+            var boxed = (object)obj;
+
+            foreach (var reader in _readers)
+                reader(input, boxed);
+
+            // Unbox it... required for value types.
+            obj = (T)boxed;
+
+            return obj;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/SByteReader.cs b/MonoGame.Framework/Content/ContentReaders/SByteReader.cs
new file mode 100644
index 00000000000..34416f870b6
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/SByteReader.cs
@@ -0,0 +1,20 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class SByteReader : ContentTypeReader<sbyte>
+    {
+        public SByteReader()
+        {
+        }
+
+        protected internal override sbyte Read(ContentReader input, sbyte existingInstance)
+        {
+            return input.ReadSByte();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/SingleReader.cs b/MonoGame.Framework/Content/ContentReaders/SingleReader.cs
new file mode 100644
index 00000000000..fd0845cb2be
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/SingleReader.cs
@@ -0,0 +1,20 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class SingleReader : ContentTypeReader<float>
+    {
+        public SingleReader()
+        {
+        }
+
+        protected internal override float Read(ContentReader input, float existingInstance)
+        {
+            return input.ReadSingle();
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Content/ContentReaders/SkinnedEffectReader.cs b/MonoGame.Framework/Content/ContentReaders/SkinnedEffectReader.cs
new file mode 100644
index 00000000000..70aa177b6f0
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/SkinnedEffectReader.cs
@@ -0,0 +1,26 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    class SkinnedEffectReader : ContentTypeReader<SkinnedEffect>
+    {
+        protected internal override SkinnedEffect Read(ContentReader input, SkinnedEffect existingInstance)
+        {
+            var effect = new SkinnedEffect(input.GraphicsDevice);
+			effect.Texture = input.ReadExternalReference<Texture> () as Texture2D;
+			effect.WeightsPerVertex = input.ReadInt32 ();
+			effect.DiffuseColor = input.ReadVector3 ();
+			effect.EmissiveColor = input.ReadVector3 ();
+			effect.SpecularColor = input.ReadVector3 ();
+			effect.SpecularPower = input.ReadSingle ();
+			effect.Alpha = input.ReadSingle ();
+            return effect;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/SongReader.cs b/MonoGame.Framework/Content/ContentReaders/SongReader.cs
new file mode 100644
index 00000000000..535476d19a9
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/SongReader.cs
@@ -0,0 +1,32 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using Microsoft.Xna.Framework.Media;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class SongReader : ContentTypeReader<Song>
+	{
+		protected internal override Song Read(ContentReader input, Song existingInstance)
+		{
+			var path = input.ReadString();
+			
+			if (!String.IsNullOrEmpty(path))
+			{
+                // Add the ContentManager's RootDirectory
+                var dirPath = Path.Combine(input.ContentManager.RootDirectoryFullPath, input.AssetName);
+
+                // Resolve the relative path
+                path = FileHelpers.ResolveRelativePath(dirPath, path);
+			}
+			
+			var durationMs = input.ReadObject<int>();
+
+            return new Song(path, durationMs); 
+		}
+	}
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/SoundEffectReader.cs b/MonoGame.Framework/Content/ContentReaders/SoundEffectReader.cs
new file mode 100644
index 00000000000..19450e2cb3f
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/SoundEffectReader.cs
@@ -0,0 +1,59 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Audio;
+
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class SoundEffectReader : ContentTypeReader<SoundEffect>
+	{
+		protected internal override SoundEffect Read(ContentReader input, SoundEffect existingInstance)
+		{         
+            // XNB format for SoundEffect...
+            //            
+            // Byte [format size]	Format	WAVEFORMATEX structure
+            // UInt32	Data size	
+            // Byte [data size]	Data	Audio waveform data
+            // Int32	Loop start	In bytes (start must be format block aligned)
+            // Int32	Loop length	In bytes (length must be format block aligned)
+            // Int32	Duration	In milliseconds
+
+            // The header containss the WAVEFORMATEX header structure
+            // defined as the following...
+            //
+            //  WORD  wFormatTag;       // byte[0]  +2
+            //  WORD  nChannels;        // byte[2]  +2
+            //  DWORD nSamplesPerSec;   // byte[4]  +4
+            //  DWORD nAvgBytesPerSec;  // byte[8]  +4
+            //  WORD  nBlockAlign;      // byte[12] +2
+            //  WORD  wBitsPerSample;   // byte[14] +2
+            //  WORD  cbSize;           // byte[16] +2
+            //
+            // We let the sound effect deal with parsing this based
+            // on what format the audio data actually is.
+
+		    var headerSize = input.ReadInt32();
+            var header = input.ReadBytes(headerSize);
+
+            // Read the audio data buffer.
+            var dataSize = input.ReadInt32();
+            var data = input.ContentManager.GetScratchBuffer(dataSize);
+            input.Read(data, 0, dataSize);
+
+            var loopStart = input.ReadInt32();
+            var loopLength = input.ReadInt32();
+            var durationMs = input.ReadInt32();
+
+            // Create the effect.
+            var effect = new SoundEffect(header, data, dataSize, durationMs, loopStart, loopLength);
+
+            // Store the original asset name for debugging later.
+            effect.Name = input.AssetName;
+
+            return effect;
+        }
+	}
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/SpriteFontReader.cs b/MonoGame.Framework/Content/ContentReaders/SpriteFontReader.cs
new file mode 100644
index 00000000000..6ffb6f5a138
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/SpriteFontReader.cs
@@ -0,0 +1,59 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class SpriteFontReader : ContentTypeReader<SpriteFont>
+    {
+        public SpriteFontReader()
+        {
+        }
+
+        protected internal override SpriteFont Read(ContentReader input, SpriteFont existingInstance)
+        {
+            if (existingInstance != null)
+            {
+                // Read the texture into the existing texture instance
+                input.ReadObject<Texture2D>(existingInstance.Texture);
+                
+                // discard the rest of the SpriteFont data as we are only reloading GPU resources for now
+                input.ReadObject<List<Rectangle>>();
+                input.ReadObject<List<Rectangle>>();
+                input.ReadObject<List<char>>();
+                input.ReadInt32();
+                input.ReadSingle();
+                input.ReadObject<List<Vector3>>();
+                if (input.ReadBoolean())
+                {
+                    input.ReadChar();
+                }
+
+                return existingInstance;
+            }
+            else
+            {
+                // Create a fresh SpriteFont instance
+                Texture2D texture = input.ReadObject<Texture2D>();
+                List<Rectangle> glyphs = input.ReadObject<List<Rectangle>>();
+                List<Rectangle> cropping = input.ReadObject<List<Rectangle>>();
+                List<char> charMap = input.ReadObject<List<char>>();
+                int lineSpacing = input.ReadInt32();
+                float spacing = input.ReadSingle();
+                List<Vector3> kerning = input.ReadObject<List<Vector3>>();
+                char? defaultCharacter = null;
+                if (input.ReadBoolean())
+                {
+                    defaultCharacter = new char?(input.ReadChar());
+                }
+                return new SpriteFont(texture, glyphs, cropping, charMap, lineSpacing, spacing, kerning, defaultCharacter);
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/StringReader.cs b/MonoGame.Framework/Content/ContentReaders/StringReader.cs
new file mode 100644
index 00000000000..da72bd4fe76
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/StringReader.cs
@@ -0,0 +1,22 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class StringReader : ContentTypeReader<String>
+    {
+        public StringReader()
+        {
+        }
+
+        protected internal override string Read(ContentReader input, string existingInstance)
+        {
+            return input.ReadString();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/Texture2DReader.cs b/MonoGame.Framework/Content/ContentReaders/Texture2DReader.cs
new file mode 100644
index 00000000000..4c12e4d0690
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/Texture2DReader.cs
@@ -0,0 +1,181 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class Texture2DReader : ContentTypeReader<Texture2D>
+    {
+		public Texture2DReader()
+		{
+			// Do nothing
+		}
+
+        protected internal override Texture2D Read(ContentReader reader, Texture2D existingInstance)
+		{
+			Texture2D texture = null;
+
+            var surfaceFormat = (SurfaceFormat)reader.ReadInt32();
+            int width = reader.ReadInt32();
+            int height = reader.ReadInt32();
+            int levelCount = reader.ReadInt32();
+            int levelCountOutput = levelCount;
+
+            // If the system does not fully support Power of Two textures,
+            // skip any mip maps supplied with any non PoT textures.
+            if (levelCount > 1 && !reader.GraphicsDevice.GraphicsCapabilities.SupportsNonPowerOfTwo &&
+                (!MathHelper.IsPowerOfTwo(width) || !MathHelper.IsPowerOfTwo(height)))
+            {
+                levelCountOutput = 1;
+                System.Diagnostics.Debug.WriteLine(
+                    "Device does not support non Power of Two textures. Skipping mipmaps.");
+            }
+
+			SurfaceFormat convertedFormat = surfaceFormat;
+			switch (surfaceFormat)
+			{
+				case SurfaceFormat.Dxt1:
+				case SurfaceFormat.Dxt1a:
+					if (!reader.GraphicsDevice.GraphicsCapabilities.SupportsDxt1)
+						convertedFormat = SurfaceFormat.Color;
+					break;
+				case SurfaceFormat.Dxt1SRgb:
+					if (!reader.GraphicsDevice.GraphicsCapabilities.SupportsDxt1)
+						convertedFormat = SurfaceFormat.ColorSRgb;
+					break;
+				case SurfaceFormat.Dxt3:
+				case SurfaceFormat.Dxt5:
+					if (!reader.GraphicsDevice.GraphicsCapabilities.SupportsS3tc)
+						convertedFormat = SurfaceFormat.Color;
+					break;
+				case SurfaceFormat.Dxt3SRgb:
+				case SurfaceFormat.Dxt5SRgb:
+					if (!reader.GraphicsDevice.GraphicsCapabilities.SupportsS3tc)
+						convertedFormat = SurfaceFormat.ColorSRgb;
+					break;
+				case SurfaceFormat.NormalizedByte4:
+					convertedFormat = SurfaceFormat.Color;
+					break;
+			}
+			
+            texture = existingInstance ?? new Texture2D(reader.GraphicsDevice, width, height, levelCountOutput > 1, convertedFormat);
+#if OPENGL
+            Threading.BlockOnUIThread(() =>
+            {
+#endif
+                for (int level = 0; level < levelCount; level++)
+			    {
+				    var levelDataSizeInBytes = reader.ReadInt32();
+                    var levelData = reader.ContentManager.GetScratchBuffer(levelDataSizeInBytes);
+                    reader.Read(levelData, 0, levelDataSizeInBytes);
+                    int levelWidth = Math.Max(width >> level, 1);
+                    int levelHeight = Math.Max(height >> level, 1);
+
+                    if (level >= levelCountOutput)
+                        continue;
+
+				    //Convert the image data if required
+				    switch (surfaceFormat)
+				    {
+					    case SurfaceFormat.Dxt1:
+                        case SurfaceFormat.Dxt1SRgb:
+                        case SurfaceFormat.Dxt1a:
+				            if (!reader.GraphicsDevice.GraphicsCapabilities.SupportsDxt1 && convertedFormat == SurfaceFormat.Color)
+				            {
+				                levelData = DxtUtil.DecompressDxt1(levelData, levelWidth, levelHeight);
+				                levelDataSizeInBytes = levelData.Length;
+				            }
+				            break;
+					    case SurfaceFormat.Dxt3:
+					    case SurfaceFormat.Dxt3SRgb:
+                            if (!reader.GraphicsDevice.GraphicsCapabilities.SupportsS3tc)
+				                if (!reader.GraphicsDevice.GraphicsCapabilities.SupportsS3tc &&
+				                    convertedFormat == SurfaceFormat.Color)
+				                {
+				                    levelData = DxtUtil.DecompressDxt3(levelData, levelWidth, levelHeight);
+                                    levelDataSizeInBytes = levelData.Length;
+                                }
+				            break;
+					    case SurfaceFormat.Dxt5:
+					    case SurfaceFormat.Dxt5SRgb:
+                            if (!reader.GraphicsDevice.GraphicsCapabilities.SupportsS3tc)
+				                if (!reader.GraphicsDevice.GraphicsCapabilities.SupportsS3tc &&
+				                    convertedFormat == SurfaceFormat.Color)
+				                {
+				                    levelData = DxtUtil.DecompressDxt5(levelData, levelWidth, levelHeight);
+                                    levelDataSizeInBytes = levelData.Length;
+                                }
+				            break;
+                        case SurfaceFormat.Bgra5551:
+                            {
+#if OPENGL
+                                // Shift the channels to suit OpenGL
+                                int offset = 0;
+                                for (int y = 0; y < levelHeight; y++)
+                                {
+                                    for (int x = 0; x < levelWidth; x++)
+                                    {
+                                        ushort pixel = BitConverter.ToUInt16(levelData, offset);
+                                        pixel = (ushort)(((pixel & 0x7FFF) << 1) | ((pixel & 0x8000) >> 15));
+                                        levelData[offset] = (byte)(pixel);
+                                        levelData[offset + 1] = (byte)(pixel >> 8);
+                                        offset += 2;
+                                    }
+                                }
+#endif
+                            }
+                            break;
+					    case SurfaceFormat.Bgra4444:
+						    {
+#if OPENGL
+                                // Shift the channels to suit OpenGL
+							    int offset = 0;
+							    for (int y = 0; y < levelHeight; y++)
+							    {
+								    for (int x = 0; x < levelWidth; x++)
+								    {
+									    ushort pixel = BitConverter.ToUInt16(levelData, offset);
+									    pixel = (ushort)(((pixel & 0x0FFF) << 4) | ((pixel & 0xF000) >> 12));
+									    levelData[offset] = (byte)(pixel);
+									    levelData[offset + 1] = (byte)(pixel >> 8);
+									    offset += 2;
+								    }
+							    }
+#endif
+						    }
+						    break;
+					    case SurfaceFormat.NormalizedByte4:
+						    {
+							    int bytesPerPixel = surfaceFormat.GetSize();
+							    int pitch = levelWidth * bytesPerPixel;
+							    for (int y = 0; y < levelHeight; y++)
+							    {
+								    for (int x = 0; x < levelWidth; x++)
+								    {
+									    int color = BitConverter.ToInt32(levelData, y * pitch + x * bytesPerPixel);
+									    levelData[y * pitch + x * 4] = (byte)(((color >> 16) & 0xff)); //R:=W
+									    levelData[y * pitch + x * 4 + 1] = (byte)(((color >> 8) & 0xff)); //G:=V
+									    levelData[y * pitch + x * 4 + 2] = (byte)(((color) & 0xff)); //B:=U
+									    levelData[y * pitch + x * 4 + 3] = (byte)(((color >> 24) & 0xff)); //A:=Q
+								    }
+							    }
+						    }
+						    break;
+				    }
+				
+                    texture.SetData(level, null, levelData, 0, levelDataSizeInBytes);
+			    }
+#if OPENGL
+            });
+#endif
+        			
+			return texture;
+		}
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/Texture3DReader.cs b/MonoGame.Framework/Content/ContentReaders/Texture3DReader.cs
new file mode 100644
index 00000000000..c5f11f5d8ad
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/Texture3DReader.cs
@@ -0,0 +1,50 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class Texture3DReader : ContentTypeReader<Texture3D>
+    {
+        protected internal override Texture3D Read(ContentReader reader, Texture3D existingInstance)
+        {
+            Texture3D texture = null;
+
+            SurfaceFormat format = (SurfaceFormat)reader.ReadInt32();
+            int width = reader.ReadInt32();
+            int height = reader.ReadInt32();
+            int depth = reader.ReadInt32();
+            int levelCount = reader.ReadInt32();
+
+            if (existingInstance == null)
+                texture = new Texture3D(reader.GraphicsDevice, width, height, depth, levelCount > 1, format);
+            else
+                texture = existingInstance;
+
+#if OPENGL
+            Threading.BlockOnUIThread(() =>
+            {
+#endif
+                for (int i = 0; i < levelCount; i++)
+                {
+                    int dataSize = reader.ReadInt32();
+                    byte[] data = reader.ContentManager.GetScratchBuffer(dataSize);
+                    reader.Read(data, 0, dataSize);
+                    texture.SetData(i, 0, 0, width, height, 0, depth, data, 0, dataSize);
+
+                    // Calculate dimensions of next mip level.
+                    width = Math.Max(width >> 1, 1);
+                    height = Math.Max(height >> 1, 1);
+                    depth = Math.Max(depth >> 1, 1);
+                }
+#if OPENGL
+            });
+#endif
+
+            return texture;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/TextureCubeReader.cs b/MonoGame.Framework/Content/ContentReaders/TextureCubeReader.cs
new file mode 100644
index 00000000000..30b626602db
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/TextureCubeReader.cs
@@ -0,0 +1,47 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class TextureCubeReader : ContentTypeReader<TextureCube>
+    {
+
+        protected internal override TextureCube Read(ContentReader reader, TextureCube existingInstance)
+        {
+            TextureCube textureCube = null;
+
+			SurfaceFormat surfaceFormat = (SurfaceFormat)reader.ReadInt32();
+			int size = reader.ReadInt32();
+			int levels = reader.ReadInt32();
+
+            if (existingInstance == null)
+                textureCube = new TextureCube(reader.GraphicsDevice, size, levels > 1, surfaceFormat);
+            else
+                textureCube = existingInstance;
+
+#if OPENGL
+            Threading.BlockOnUIThread(() =>
+            {
+#endif
+                for (int face = 0; face < 6; face++)
+                {
+                    for (int i = 0; i < levels; i++)
+                    {
+                        int faceSize = reader.ReadInt32();
+                        byte[] faceData = reader.ContentManager.GetScratchBuffer(faceSize);
+                        reader.Read(faceData, 0, faceSize);
+                        textureCube.SetData<byte>((CubeMapFace)face, i, null, faceData, 0, faceSize);
+                    }
+                }
+#if OPENGL
+            });
+#endif
+
+             return textureCube;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/TextureReader.cs b/MonoGame.Framework/Content/ContentReaders/TextureReader.cs
new file mode 100644
index 00000000000..01bef184e30
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/TextureReader.cs
@@ -0,0 +1,17 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class TextureReader : ContentTypeReader<Texture>
+	{
+		protected internal override Texture Read(ContentReader reader, Texture existingInstance)
+		{
+			return existingInstance;
+		}
+	}
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Content/ContentReaders/TimeSpanReader.cs b/MonoGame.Framework/Content/ContentReaders/TimeSpanReader.cs
new file mode 100644
index 00000000000..c5e28d97339
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/TimeSpanReader.cs
@@ -0,0 +1,28 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+using Microsoft.Xna.Framework.Content;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class TimeSpanReader : ContentTypeReader<TimeSpan>
+	{
+		public TimeSpanReader ()
+		{
+		}
+
+		protected internal override TimeSpan Read (ContentReader input, TimeSpan existingInstance)
+		{
+			// Could not find any information on this really but from all the searching it looks
+			// like the constructor of number of ticks is long so I have placed that here for now
+			// long is a Int64 so we read with 64
+			// <Duration>PT2S</Duration>
+			// 
+			
+			return new TimeSpan(input.ReadInt64 ());
+		}
+	}
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/UInt16Reader.cs b/MonoGame.Framework/Content/ContentReaders/UInt16Reader.cs
new file mode 100644
index 00000000000..6ba6ce6b6fe
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/UInt16Reader.cs
@@ -0,0 +1,20 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class UInt16Reader : ContentTypeReader<ushort>
+    {
+        public UInt16Reader()
+        {
+        }
+
+        protected internal override ushort Read(ContentReader input, ushort existingInstance)
+        {
+            return input.ReadUInt16();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/UInt32Reader.cs b/MonoGame.Framework/Content/ContentReaders/UInt32Reader.cs
new file mode 100644
index 00000000000..27d01487af6
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/UInt32Reader.cs
@@ -0,0 +1,20 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class UInt32Reader : ContentTypeReader<uint>
+    {
+        public UInt32Reader()
+        {
+        }
+
+        protected internal override uint Read(ContentReader input, uint existingInstance)
+        {
+            return input.ReadUInt32();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/UInt64Reader.cs b/MonoGame.Framework/Content/ContentReaders/UInt64Reader.cs
new file mode 100644
index 00000000000..f4587196a98
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/UInt64Reader.cs
@@ -0,0 +1,20 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class UInt64Reader : ContentTypeReader<ulong>
+    {
+        public UInt64Reader()
+        {
+        }
+
+        protected internal override ulong Read(ContentReader input, ulong existingInstance)
+        {
+            return input.ReadUInt64();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/Vector2Reader.cs b/MonoGame.Framework/Content/ContentReaders/Vector2Reader.cs
new file mode 100644
index 00000000000..93c914c36a9
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/Vector2Reader.cs
@@ -0,0 +1,22 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+using Microsoft.Xna.Framework.Content;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	internal class Vector2Reader : ContentTypeReader<Vector2>
+	{
+		public Vector2Reader ()
+		{
+		}
+
+		protected internal override Vector2 Read (ContentReader input, Vector2 existingInstance)
+		{
+			return input.ReadVector2 ();
+		}
+	}
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/Vector3Reader.cs b/MonoGame.Framework/Content/ContentReaders/Vector3Reader.cs
new file mode 100644
index 00000000000..acaac447d56
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/Vector3Reader.cs
@@ -0,0 +1,22 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class Vector3Reader : ContentTypeReader<Vector3>
+    {
+        public Vector3Reader()
+        {
+        }
+
+        protected internal override Vector3 Read(ContentReader input, Vector3 existingInstance)
+        {
+            return input.ReadVector3();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/Vector4Reader.cs b/MonoGame.Framework/Content/ContentReaders/Vector4Reader.cs
new file mode 100644
index 00000000000..2ae64e41449
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/Vector4Reader.cs
@@ -0,0 +1,20 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class Vector4Reader : ContentTypeReader<Vector4>
+    {
+        public Vector4Reader()
+        {
+        }
+
+        protected internal override Vector4 Read(ContentReader input, Vector4 existingInstance)
+        {
+            return input.ReadVector4();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/VertexBufferReader.cs b/MonoGame.Framework/Content/ContentReaders/VertexBufferReader.cs
new file mode 100644
index 00000000000..1a890ec63e8
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/VertexBufferReader.cs
@@ -0,0 +1,25 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    class VertexBufferReader : ContentTypeReader<VertexBuffer>
+    {
+        protected internal override VertexBuffer Read(ContentReader input, VertexBuffer existingInstance)
+        {
+            var declaration = input.ReadRawObject<VertexDeclaration>();
+            var vertexCount = (int)input.ReadUInt32();
+            int dataSize = vertexCount * declaration.VertexStride;
+            byte[] data = input.ContentManager.GetScratchBuffer(dataSize);
+            input.Read(data, 0, dataSize);
+
+            var buffer = new VertexBuffer(input.GraphicsDevice, declaration, vertexCount, BufferUsage.None);
+            buffer.SetData(data, 0, dataSize);
+            return buffer;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/VertexDeclarationReader.cs b/MonoGame.Framework/Content/ContentReaders/VertexDeclarationReader.cs
new file mode 100644
index 00000000000..169a6601895
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/VertexDeclarationReader.cs
@@ -0,0 +1,27 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using Microsoft.Xna.Framework.Graphics;
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class VertexDeclarationReader : ContentTypeReader<VertexDeclaration>
+	{
+		protected internal override VertexDeclaration Read(ContentReader reader, VertexDeclaration existingInstance)
+        {
+			var vertexStride = reader.ReadInt32();
+			var elementCount = reader.ReadInt32();
+			VertexElement[] elements = new VertexElement[elementCount];
+			for (int i = 0; i < elementCount; ++i)
+			{
+				var offset = reader.ReadInt32();
+				var elementFormat = (VertexElementFormat)reader.ReadInt32();
+				var elementUsage = (VertexElementUsage)reader.ReadInt32();
+				var usageIndex = reader.ReadInt32();
+				elements[i] = new VertexElement(offset, elementFormat, elementUsage, usageIndex);
+			}
+
+            return VertexDeclaration.GetOrCreate(vertexStride, elements);
+		}
+	}
+}
diff --git a/MonoGame.Framework/Content/ContentReaders/VideoReader.cs b/MonoGame.Framework/Content/ContentReaders/VideoReader.cs
new file mode 100644
index 00000000000..941ca5d5983
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentReaders/VideoReader.cs
@@ -0,0 +1,42 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using Microsoft.Xna.Framework.Media;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    internal class VideoReader : ContentTypeReader<Video>
+    {
+        protected internal override Video Read(ContentReader input, Video existingInstance)
+        {
+            string path = input.ReadObject<string>();
+
+            if (!string.IsNullOrEmpty(path))
+            {
+                // Add the ContentManager's RootDirectory
+                var dirPath = Path.Combine(input.ContentManager.RootDirectoryFullPath, input.AssetName);
+
+                // Resolve the relative path
+                path = FileHelpers.ResolveRelativePath(dirPath, path);
+            }
+
+            var durationMS = input.ReadObject<int>();
+            var width = input.ReadObject<int>();
+            var height = input.ReadObject<int>();
+            var framesPerSecond = input.ReadObject<float>();
+            var soundTrackType = input.ReadObject<int>();  // 0 = Music, 1 = Dialog, 2 = Music and dialog
+
+            return new Video(path, durationMS)
+            {
+                Width = width,
+                Height = height,
+                FramesPerSecond = framesPerSecond,
+                VideoSoundtrackType = (VideoSoundtrackType)soundTrackType
+            };
+        }
+    }
+}
diff --git a/MonoGame.Framework/Content/ContentSerializerAttribute.cs b/MonoGame.Framework/Content/ContentSerializerAttribute.cs
new file mode 100644
index 00000000000..708d6b7b436
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentSerializerAttribute.cs
@@ -0,0 +1,74 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{	
+    [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
+    public sealed class ContentSerializerAttribute : Attribute
+    {
+        private string _collectionItemName;
+
+        /// <summary>
+        /// Creates an instance of the attribute.
+        /// </summary>
+        public ContentSerializerAttribute()
+        {
+            AllowNull = true;
+        }
+
+        public bool AllowNull { get; set; }
+
+        /// <summary>
+        /// Returns the overriden XML element name or the default "Item".
+        /// </summary>
+        public string CollectionItemName
+        {
+            get
+            {
+                // Return the defaul if unset.
+                if (string.IsNullOrEmpty(_collectionItemName))
+                    return "Item";
+
+                return _collectionItemName;
+            }
+            set
+            {
+                _collectionItemName = value;
+            }
+        }
+
+        public string ElementName { get; set; }
+
+        public bool FlattenContent { get; set; }
+
+        /// <summary>
+        /// Returns true if the default CollectionItemName value was overridden.
+        /// </summary>
+        public bool HasCollectionItemName
+        {
+            get
+            {
+                return !string.IsNullOrEmpty(_collectionItemName);
+            }
+        }
+
+        public bool Optional { get; set; }
+
+        public bool SharedResource { get; set; }
+
+        public ContentSerializerAttribute Clone()
+        {
+            var clone = new ContentSerializerAttribute ();
+            clone.AllowNull = AllowNull;
+            clone._collectionItemName = _collectionItemName;
+            clone.ElementName = ElementName;
+            clone.FlattenContent = FlattenContent;
+            clone.Optional = Optional;
+            clone.SharedResource = SharedResource;
+            return clone;
+        }
+    }
+} 
diff --git a/MonoGame.Framework/Content/ContentSerializerCollectionItemNameAttribute.cs b/MonoGame.Framework/Content/ContentSerializerCollectionItemNameAttribute.cs
new file mode 100644
index 00000000000..de9a6b2d34e
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentSerializerCollectionItemNameAttribute.cs
@@ -0,0 +1,30 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    /// <summary>
+    /// This is used to specify the XML element name to use for each item in a collection.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class)]
+    public sealed class ContentSerializerCollectionItemNameAttribute : Attribute
+    {
+        /// <summary>
+        /// Creates an instance of the attribute.
+        /// </summary>
+        /// <param name="collectionItemName">The XML element name to use for each item in the collection.</param>
+        public ContentSerializerCollectionItemNameAttribute(string collectionItemName)
+        {
+            CollectionItemName = collectionItemName;
+        }
+
+        /// <summary>
+        /// The XML element name to use for each item in the collection.
+        /// </summary>
+        public string CollectionItemName { get; private set;}
+    }
+}
+
diff --git a/MonoGame.Framework/Content/ContentSerializerIgnoreAttribute.cs b/MonoGame.Framework/Content/ContentSerializerIgnoreAttribute.cs
new file mode 100644
index 00000000000..79d23026dfa
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentSerializerIgnoreAttribute.cs
@@ -0,0 +1,57 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+//
+// Author: Kenneth James Pouncey
+//
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	// http://msdn.microsoft.com/en-us/library/bb195465.aspx
+	// The class definition on msdn site shows: [AttributeUsageAttribute(384)]
+	// The following code var ff = (AttributeTargets)384; shows that ff is Field | Property
+	//  so that is what we use.
+	[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+	public sealed class ContentSerializerIgnoreAttribute : Attribute
+	{
+	}
+
+}
+
diff --git a/MonoGame.Framework/Content/ContentSerializerRuntimeTypeAttribute.cs b/MonoGame.Framework/Content/ContentSerializerRuntimeTypeAttribute.cs
new file mode 100644
index 00000000000..8a23c9e57af
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentSerializerRuntimeTypeAttribute.cs
@@ -0,0 +1,30 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    /// <summary>
+    /// This is used to specify the type to use when deserializing this object at runtime.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Struct | AttributeTargets.Class)]
+    public sealed class ContentSerializerRuntimeTypeAttribute : Attribute
+    {
+        /// <summary>
+        /// Creates an instance of the attribute.
+        /// </summary>
+        /// <param name="runtimeType">The name of the type to use at runtime.</param>
+        public ContentSerializerRuntimeTypeAttribute(string runtimeType)
+        {
+            RuntimeType = runtimeType;
+        }
+
+        /// <summary>
+        /// The name of the type to use at runtime.
+        /// </summary>
+        public string RuntimeType { get; private set;}
+    }
+}
+
diff --git a/MonoGame.Framework/Content/ContentSerializerTypeVersionAttribute.cs b/MonoGame.Framework/Content/ContentSerializerTypeVersionAttribute.cs
new file mode 100644
index 00000000000..1d29c50a70e
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentSerializerTypeVersionAttribute.cs
@@ -0,0 +1,30 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    /// <summary>
+    /// This is used to specify the version when deserializing this object at runtime.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Struct | AttributeTargets.Class)]
+    public sealed class ContentSerializerTypeVersionAttribute : Attribute
+    {
+        /// <summary>
+        /// Creates an instance of the attribute.
+        /// </summary>
+        /// <param name="typeVersion">The version passed to the type at runtime.</param>
+        public ContentSerializerTypeVersionAttribute(int typeVersion)
+        {
+            TypeVersion = typeVersion;
+        }
+
+        /// <summary>
+        /// The version passed to the type at runtime.
+        /// </summary>
+        public int TypeVersion { get; private set; }
+    }
+}
+
diff --git a/MonoGame.Framework/Content/ContentTypeReader.cs b/MonoGame.Framework/Content/ContentTypeReader.cs
new file mode 100644
index 00000000000..7b478746783
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentTypeReader.cs
@@ -0,0 +1,64 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    public abstract class ContentTypeReader
+    {
+        private Type _targetType;
+
+        public virtual bool CanDeserializeIntoExistingObject
+        {
+            get { return false; }
+        }
+
+        public Type TargetType
+        {
+            get { return _targetType; }
+        }
+
+        public virtual int TypeVersion
+        {
+            get { return 0; }   // The default version (unless overridden) is zero
+        }
+
+        protected ContentTypeReader(Type targetType)
+        {
+            _targetType = targetType;
+        }
+
+        protected internal virtual void Initialize(ContentTypeReaderManager manager)
+        {
+            // Do nothing. Are we supposed to add ourselves to the manager?
+        }
+
+        protected internal abstract object Read(ContentReader input, object existingInstance);
+    }
+
+    public abstract class ContentTypeReader<T> : ContentTypeReader
+    {
+        protected ContentTypeReader()
+            : base(typeof(T))
+        {
+            // Nothing
+        }
+
+        protected internal override object Read(ContentReader input, object existingInstance)
+        {
+			// as per the documentation http://msdn.microsoft.com/en-us/library/microsoft.xna.framework.content.contenttypereader.read.aspx
+			// existingInstance
+			// The object receiving the data, or null if a new instance of the object should be created.
+			if (existingInstance == null)
+            {
+				return Read(input, default(T));
+			} 
+			return Read(input, (T)existingInstance);
+        }
+
+        protected internal abstract T Read(ContentReader input, T existingInstance);
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Content/ContentTypeReaderManager.cs b/MonoGame.Framework/Content/ContentTypeReaderManager.cs
new file mode 100644
index 00000000000..e3c49fc0a7b
--- /dev/null
+++ b/MonoGame.Framework/Content/ContentTypeReaderManager.cs
@@ -0,0 +1,255 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections;
+using System.Reflection;
+using System.Text.RegularExpressions;
+using System.Collections.Generic;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    public sealed class ContentTypeReaderManager
+    {
+        private static readonly object _locker;
+
+        private static readonly Dictionary<Type, ContentTypeReader> _contentReadersCache;
+
+        private Dictionary<Type, ContentTypeReader> _contentReaders;
+
+		private static readonly string _assemblyName;
+		
+
+		static ContentTypeReaderManager()
+		{
+            _locker = new object();
+            _contentReadersCache = new Dictionary<Type, ContentTypeReader>(255);
+            _assemblyName = ReflectionHelpers.GetAssembly(typeof(ContentTypeReaderManager)).FullName;
+        }
+
+        public ContentTypeReader GetTypeReader(Type targetType)
+        {
+            if (targetType.IsArray && targetType.GetArrayRank() > 1)
+                targetType = typeof(Array);
+
+            ContentTypeReader reader;
+            if (_contentReaders.TryGetValue(targetType, out reader))
+                return reader;
+
+            return null;
+        }
+
+        // Trick to prevent the linker removing the code, but not actually execute the code
+        static bool falseflag = false;
+
+		internal ContentTypeReader[] LoadAssetReaders(ContentReader reader)
+        {
+#pragma warning disable 0219, 0649
+            // Trick to prevent the linker removing the code, but not actually execute the code
+            if (falseflag)
+            {
+                // Dummy variables required for it to work on iDevices ** DO NOT DELETE ** 
+                // This forces the classes not to be optimized out when deploying to iDevices
+                var hByteReader = new ByteReader();
+                var hSByteReader = new SByteReader();
+                var hDateTimeReader = new DateTimeReader();
+                var hDecimalReader = new DecimalReader();
+                var hBoundingSphereReader = new BoundingSphereReader();
+                var hBoundingFrustumReader = new BoundingFrustumReader();
+                var hRayReader = new RayReader();
+                var hCharListReader = new ListReader<Char>();
+                var hRectangleListReader = new ListReader<Rectangle>();
+                var hRectangleArrayReader = new ArrayReader<Rectangle>();
+                var hVector3ListReader = new ListReader<Vector3>();
+                var hStringListReader = new ListReader<StringReader>();
+				var hIntListReader = new ListReader<Int32>();
+                var hSpriteFontReader = new SpriteFontReader();
+                var hTexture2DReader = new Texture2DReader();
+                var hCharReader = new CharReader();
+                var hRectangleReader = new RectangleReader();
+                var hStringReader = new StringReader();
+                var hVector2Reader = new Vector2Reader();
+                var hVector3Reader = new Vector3Reader();
+                var hVector4Reader = new Vector4Reader();
+                var hCurveReader = new CurveReader();
+                var hIndexBufferReader = new IndexBufferReader();
+                var hBoundingBoxReader = new BoundingBoxReader();
+                var hMatrixReader = new MatrixReader();
+                var hBasicEffectReader = new BasicEffectReader();
+                var hVertexBufferReader = new VertexBufferReader();
+                var hAlphaTestEffectReader = new AlphaTestEffectReader();
+                var hEnumSpriteEffectsReader = new EnumReader<Graphics.SpriteEffects>();
+                var hArrayFloatReader = new ArrayReader<float>();
+                var hArrayVector2Reader = new ArrayReader<Vector2>();
+                var hListVector2Reader = new ListReader<Vector2>();
+                var hArrayMatrixReader = new ArrayReader<Matrix>();
+                var hEnumBlendReader = new EnumReader<Graphics.Blend>();
+                var hNullableRectReader = new NullableReader<Rectangle>();
+				var hEffectMaterialReader = new EffectMaterialReader();
+				var hExternalReferenceReader = new ExternalReferenceReader();
+                var hSoundEffectReader = new SoundEffectReader();
+                var hSongReader = new SongReader();
+                var hModelReader = new ModelReader();
+                var hInt32Reader = new Int32Reader();
+                var hEffectReader = new EffectReader();
+                var hSingleReader = new SingleReader();
+
+                // At the moment the Video class doesn't exist
+                // on all platforms... Allow it to compile anyway.
+#if ANDROID || (IOS && !TVOS) || MONOMAC || (WINDOWS && !OPENGL) || WINDOWS_UAP
+                var hVideoReader = new VideoReader();
+#endif
+            }
+#pragma warning restore 0219, 0649
+
+		    // The first content byte i read tells me the number of content readers in this XNB file
+            var numberOfReaders = reader.Read7BitEncodedInt();
+            var contentReaders = new ContentTypeReader[numberOfReaders];
+            var needsInitialize = new BitArray(numberOfReaders);
+            _contentReaders = new Dictionary<Type, ContentTypeReader>(numberOfReaders);
+
+            // Lock until we're done allocating and initializing any new
+            // content type readers...  this ensures we can load content
+            // from multiple threads and still cache the readers.
+            lock (_locker)
+            {
+                // For each reader in the file, we read out the length of the string which contains the type of the reader,
+                // then we read out the string. Finally we instantiate an instance of that reader using reflection
+                for (var i = 0; i < numberOfReaders; i++)
+                {
+                    // This string tells us what reader we need to decode the following data
+                    // string readerTypeString = reader.ReadString();
+                    string originalReaderTypeString = reader.ReadString();
+
+                    Func<ContentTypeReader> readerFunc;
+                    if (typeCreators.TryGetValue(originalReaderTypeString, out readerFunc))
+                    {
+                        contentReaders[i] = readerFunc();
+                        needsInitialize[i] = true;
+                    }
+                    else
+                    {
+                        //System.Diagnostics.Debug.WriteLine(originalReaderTypeString);
+
+                        // Need to resolve namespace differences
+                        string readerTypeString = originalReaderTypeString;
+
+                        readerTypeString = PrepareType(readerTypeString);
+
+                        var l_readerType = Type.GetType(readerTypeString);
+                        if (l_readerType != null)
+                        {
+                            ContentTypeReader typeReader;
+                            if (!_contentReadersCache.TryGetValue(l_readerType, out typeReader))
+                            {
+                                try
+                                {
+                                    typeReader = l_readerType.GetDefaultConstructor().Invoke(null) as ContentTypeReader;
+                                }
+                                catch (TargetInvocationException ex)
+                                {
+                                    // If you are getting here, the Mono runtime is most likely not able to JIT the type.
+                                    // In particular, MonoTouch needs help instantiating types that are only defined in strings in Xnb files. 
+                                    throw new InvalidOperationException(
+                                        "Failed to get default constructor for ContentTypeReader. To work around, add a creation function to ContentTypeReaderManager.AddTypeCreator() " +
+                                        "with the following failed type string: " + originalReaderTypeString, ex);
+                                }
+
+                                needsInitialize[i] = true;
+
+                                _contentReadersCache.Add(l_readerType, typeReader);
+                            }
+
+                            contentReaders[i] = typeReader;
+                        }
+                        else
+                            throw new ContentLoadException(
+                                    "Could not find ContentTypeReader Type. Please ensure the name of the Assembly that contains the Type matches the assembly in the full type name: " +
+                                    originalReaderTypeString + " (" + readerTypeString + ")");
+                    }
+
+                    var targetType = contentReaders[i].TargetType;
+                    if (targetType != null)
+                        if (!_contentReaders.ContainsKey(targetType))
+                            _contentReaders.Add(targetType, contentReaders[i]);
+
+                    // I think the next 4 bytes refer to the "Version" of the type reader,
+                    // although it always seems to be zero
+                    reader.ReadInt32();
+                }
+
+                // Initialize any new readers.
+                for (var i = 0; i < contentReaders.Length; i++)
+                {
+                    if (needsInitialize.Get(i))
+                        contentReaders[i].Initialize(this);
+                }
+
+            } // lock (_locker)
+
+		    return contentReaders;
+        }
+		
+		/// <summary>
+		/// Removes Version, Culture and PublicKeyToken from a type string.
+		/// </summary>
+		/// <remarks>
+        /// Supports multiple generic types (e.g. Dictionary&lt;TKey,TValue&gt;) and nested generic types (e.g. List&lt;List&lt;int&gt;&gt;).
+		/// </remarks> 
+		/// <param name="type">
+		/// A <see cref="System.String"/>
+		/// </param>
+		/// <returns>
+		/// A <see cref="System.String"/>
+		/// </returns>
+		public static string PrepareType(string type)
+		{			
+			//Needed to support nested types
+			int count = type.Split(new[] {"[["}, StringSplitOptions.None).Length - 1;
+			
+			string preparedType = type;
+			
+			for(int i=0; i<count; i++)
+			{
+				preparedType = Regex.Replace(preparedType, @"\[(.+?), Version=.+?\]", "[$1]");
+			}
+						
+			//Handle non generic types
+			if(preparedType.Contains("PublicKeyToken"))
+				preparedType = Regex.Replace(preparedType, @"(.+?), Version=.+?$", "$1");
+
+			// TODO: For WinRT this is most likely broken!
+			preparedType = preparedType.Replace(", Microsoft.Xna.Framework.Graphics", string.Format(", {0}", _assemblyName));
+            preparedType = preparedType.Replace(", Microsoft.Xna.Framework.Video", string.Format(", {0}", _assemblyName));
+            preparedType = preparedType.Replace(", Microsoft.Xna.Framework", string.Format(", {0}", _assemblyName));
+			
+			return preparedType;
+		}
+
+        // Static map of type names to creation functions. Required as iOS requires all types at compile time
+        private static Dictionary<string, Func<ContentTypeReader>> typeCreators = new Dictionary<string, Func<ContentTypeReader>>();
+
+        /// <summary>
+        /// Adds the type creator.
+        /// </summary>
+        /// <param name='typeString'>
+        /// Type string.
+        /// </param>
+        /// <param name='createFunction'>
+        /// Create function.
+        /// </param>
+        public static void AddTypeCreator(string typeString, Func<ContentTypeReader> createFunction)
+        {
+            if (!typeCreators.ContainsKey(typeString))
+                typeCreators.Add(typeString, createFunction);
+        }
+
+        public static void ClearTypeCreators()
+        {
+            typeCreators.Clear();
+        }
+
+    }
+}
diff --git a/MonoGame.Framework/Content/LzxDecoder.cs b/MonoGame.Framework/Content/LzxDecoder.cs
new file mode 100644
index 00000000000..bf8330a9fcf
--- /dev/null
+++ b/MonoGame.Framework/Content/LzxDecoder.cs
@@ -0,0 +1,780 @@
+#region HEADER
+/* This file was derived from libmspack
+ * (C) 2003-2004 Stuart Caie.
+ * (C) 2011 Ali Scissons.
+ *
+ * The LZX method was created by Jonathan Forbes and Tomi Poutanen, adapted
+ * by Microsoft Corporation.
+ *
+ * This source file is Dual licensed; meaning the end-user of this source file
+ * may redistribute/modify it under the LGPL 2.1 or MS-PL licenses.
+ */ 
+#region LGPL License
+/* GNU LESSER GENERAL PUBLIC LICENSE version 2.1
+ * LzxDecoder is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License (LGPL) version 2.1 
+ */
+#endregion
+#region MS-PL License
+/* 
+ * MICROSOFT PUBLIC LICENSE
+ * This source code is subject to the terms of the Microsoft Public License (Ms-PL). 
+ *  
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * is permitted provided that redistributions of the source code retain the above 
+ * copyright notices and this file header. 
+ *  
+ * Additional copyright notices should be appended to the list above. 
+ * 
+ * For details, see <http://www.opensource.org/licenses/ms-pl.html>. 
+ */
+#endregion
+/*
+ * This derived work is recognized by Stuart Caie and is authorized to adapt
+ * any changes made to lzxd.c in his libmspack library and will still retain
+ * this dual licensing scheme. Big thanks to Stuart Caie!
+ * 
+ * DETAILS
+ * This file is a pure C# port of the lzxd.c file from libmspack, with minor
+ * changes towards the decompression of XNB files. The original decompression
+ * software of LZX encoded data was written by Suart Caie in his
+ * libmspack/cabextract projects, which can be located at 
+ * http://http://www.cabextract.org.uk/
+ */
+#endregion
+
+using System;
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework.Content
+{
+	using System.IO;
+	
+	class LzxDecoder
+	{
+		public static uint[] position_base = null;
+		public static byte[] extra_bits = null;
+		
+		private LzxState m_state;
+		
+		public LzxDecoder (int window)
+		{
+			uint wndsize = (uint)(1 << window);
+			int posn_slots;
+			
+			// setup proper exception
+			if(window < 15 || window > 21) throw new UnsupportedWindowSizeRange();
+			
+			// let's initialise our state
+			m_state = new LzxState();
+			m_state.actual_size = 0;
+			m_state.window = new byte[wndsize];
+			for(int i = 0; i < wndsize; i++) m_state.window[i] = 0xDC;
+			m_state.actual_size = wndsize;
+			m_state.window_size = wndsize;
+			m_state.window_posn = 0;
+			
+			/* initialize static tables */
+			if(extra_bits == null)
+			{
+				extra_bits = new byte[52];
+				for(int i = 0, j = 0; i <= 50; i += 2)
+				{
+					extra_bits[i] = extra_bits[i+1] = (byte)j;
+					if ((i != 0) && (j < 17)) j++;
+				}
+			}
+			if(position_base == null)
+			{
+				position_base = new uint[51];
+				for(int i = 0, j = 0; i <= 50; i++)
+				{
+					position_base[i] = (uint)j;
+					j += 1 << extra_bits[i];
+				}
+			}
+			
+			/* calculate required position slots */
+			if(window == 20) posn_slots = 42;
+			else if(window == 21) posn_slots = 50;
+			else posn_slots = window << 1;
+			
+			m_state.R0 = m_state.R1 = m_state.R2 = 1;
+			m_state.main_elements = (ushort)(LzxConstants.NUM_CHARS + (posn_slots << 3));
+			m_state.header_read = 0;
+			m_state.frames_read = 0;
+			m_state.block_remaining = 0;
+			m_state.block_type = LzxConstants.BLOCKTYPE.INVALID;
+			m_state.intel_curpos = 0;
+			m_state.intel_started = 0;
+			
+			// yo dawg i herd u liek arrays so we put arrays in ur arrays so u can array while u array
+			m_state.PRETREE_table = new ushort[(1 << LzxConstants.PRETREE_TABLEBITS) + (LzxConstants.PRETREE_MAXSYMBOLS << 1)];
+			m_state.PRETREE_len = new byte[LzxConstants.PRETREE_MAXSYMBOLS + LzxConstants.LENTABLE_SAFETY];
+			m_state.MAINTREE_table = new ushort[(1 << LzxConstants.MAINTREE_TABLEBITS) + (LzxConstants.MAINTREE_MAXSYMBOLS << 1)];
+			m_state.MAINTREE_len = new byte[LzxConstants.MAINTREE_MAXSYMBOLS + LzxConstants.LENTABLE_SAFETY];
+			m_state.LENGTH_table = new ushort[(1 << LzxConstants.LENGTH_TABLEBITS) + (LzxConstants.LENGTH_MAXSYMBOLS << 1)];
+			m_state.LENGTH_len = new byte[LzxConstants.LENGTH_MAXSYMBOLS + LzxConstants.LENTABLE_SAFETY];
+			m_state.ALIGNED_table = new ushort[(1 << LzxConstants.ALIGNED_TABLEBITS) + (LzxConstants.ALIGNED_MAXSYMBOLS << 1)];
+			m_state.ALIGNED_len = new byte[LzxConstants.ALIGNED_MAXSYMBOLS + LzxConstants.LENTABLE_SAFETY];
+			/* initialise tables to 0 (because deltas will be applied to them) */
+			for(int i = 0; i < LzxConstants.MAINTREE_MAXSYMBOLS; i++) m_state.MAINTREE_len[i] = 0;
+			for(int i = 0; i < LzxConstants.LENGTH_MAXSYMBOLS; i++) m_state.LENGTH_len[i] = 0;
+		}
+		
+		public int Decompress(Stream inData, int inLen, Stream outData, int outLen)
+		{
+			BitBuffer bitbuf = new BitBuffer(inData);
+			long startpos = inData.Position;
+			long endpos = inData.Position + inLen;
+			
+			byte[] window = m_state.window;
+			
+			uint window_posn = m_state.window_posn;
+			uint window_size = m_state.window_size;
+			uint R0 = m_state.R0;
+			uint R1 = m_state.R1;
+			uint R2 = m_state.R2;
+			uint i, j;
+			
+			int togo = outLen, this_run, main_element, match_length, match_offset, length_footer, extra, verbatim_bits;
+			int rundest, runsrc, copy_length, aligned_bits;
+			
+			bitbuf.InitBitStream();
+			
+			/* read header if necessary */
+			if(m_state.header_read == 0)
+			{
+				uint intel = bitbuf.ReadBits(1);
+				if(intel != 0)
+				{
+					// read the filesize
+					i = bitbuf.ReadBits(16); j = bitbuf.ReadBits(16);
+					m_state.intel_filesize = (int)((i << 16) | j);
+				}
+				m_state.header_read = 1;
+			}
+			
+			/* main decoding loop */
+			while(togo > 0)
+			{
+				/* last block finished, new block expected */
+				if(m_state.block_remaining == 0)
+				{
+					// TODO may screw something up here
+					if(m_state.block_type == LzxConstants.BLOCKTYPE.UNCOMPRESSED) {
+						if((m_state.block_length & 1) == 1) inData.ReadByte(); /* realign bitstream to word */
+						bitbuf.InitBitStream();
+					}
+					
+					m_state.block_type = (LzxConstants.BLOCKTYPE)bitbuf.ReadBits(3);;
+					i = bitbuf.ReadBits(16);
+					j = bitbuf.ReadBits(8);
+					m_state.block_remaining = m_state.block_length = (uint)((i << 8) | j);
+					
+					switch(m_state.block_type)
+					{
+					case LzxConstants.BLOCKTYPE.ALIGNED:
+						for(i = 0, j = 0; i < 8; i++) { j = bitbuf.ReadBits(3); m_state.ALIGNED_len[i] = (byte)j; }
+						MakeDecodeTable(LzxConstants.ALIGNED_MAXSYMBOLS, LzxConstants.ALIGNED_TABLEBITS,
+						                m_state.ALIGNED_len, m_state.ALIGNED_table);
+						/* rest of aligned header is same as verbatim */
+						goto case LzxConstants.BLOCKTYPE.VERBATIM;
+						
+					case LzxConstants.BLOCKTYPE.VERBATIM:
+						ReadLengths(m_state.MAINTREE_len, 0, 256, bitbuf);
+						ReadLengths(m_state.MAINTREE_len, 256, m_state.main_elements, bitbuf);
+						MakeDecodeTable(LzxConstants.MAINTREE_MAXSYMBOLS, LzxConstants.MAINTREE_TABLEBITS,
+						                m_state.MAINTREE_len, m_state.MAINTREE_table);
+						if(m_state.MAINTREE_len[0xE8] != 0) m_state.intel_started = 1;
+						
+						ReadLengths(m_state.LENGTH_len, 0, LzxConstants.NUM_SECONDARY_LENGTHS, bitbuf);
+						MakeDecodeTable(LzxConstants.LENGTH_MAXSYMBOLS, LzxConstants.LENGTH_TABLEBITS,
+						                m_state.LENGTH_len, m_state.LENGTH_table);
+						break;
+						
+					case LzxConstants.BLOCKTYPE.UNCOMPRESSED:
+						m_state.intel_started = 1; /* because we can't assume otherwise */
+						bitbuf.EnsureBits(16); /* get up to 16 pad bits into the buffer */
+						if(bitbuf.GetBitsLeft() > 16) inData.Seek(-2, SeekOrigin.Current); /* and align the bitstream! */
+						byte hi, mh, ml, lo;
+						lo = (byte)inData.ReadByte(); ml = (byte)inData.ReadByte(); mh = (byte)inData.ReadByte(); hi = (byte)inData.ReadByte();
+						R0 = (uint)(lo | ml << 8 | mh << 16 | hi << 24);
+						lo = (byte)inData.ReadByte(); ml = (byte)inData.ReadByte(); mh = (byte)inData.ReadByte(); hi = (byte)inData.ReadByte();
+						R1 = (uint)(lo | ml << 8 | mh << 16 | hi << 24);
+						lo = (byte)inData.ReadByte(); ml = (byte)inData.ReadByte(); mh = (byte)inData.ReadByte(); hi = (byte)inData.ReadByte();
+						R2 = (uint)(lo | ml << 8 | mh << 16 | hi << 24);
+						break;
+						
+					default:
+						return -1; // TODO throw proper exception
+					}
+				}
+				
+				/* buffer exhaustion check */
+				if(inData.Position > (startpos + inLen))
+				{
+					/* it's possible to have a file where the next run is less than
+				     * 16 bits in size. In this case, the READ_HUFFSYM() macro used
+				     * in building the tables will exhaust the buffer, so we should
+				     * allow for this, but not allow those accidentally read bits to
+				     * be used (so we check that there are at least 16 bits
+				     * remaining - in this boundary case they aren't really part of
+				     * the compressed data)
+					 */
+					//Debug.WriteLine("WTF");
+
+					if(inData.Position > (startpos+inLen+2) || bitbuf.GetBitsLeft() < 16) return -1; //TODO throw proper exception
+				}
+				
+				while((this_run = (int)m_state.block_remaining) > 0 && togo > 0)
+				{
+					if(this_run > togo) this_run = togo;
+					togo -= this_run;
+					m_state.block_remaining -= (uint)this_run;
+					
+					/* apply 2^x-1 mask */
+					window_posn &= window_size - 1;
+					/* runs can't straddle the window wraparound */
+					if((window_posn + this_run) > window_size)
+						return -1; //TODO throw proper exception
+					
+					switch(m_state.block_type)
+					{
+					case LzxConstants.BLOCKTYPE.VERBATIM:
+						while(this_run > 0)
+						{
+							main_element = (int)ReadHuffSym(m_state.MAINTREE_table, m_state.MAINTREE_len,
+							                           LzxConstants.MAINTREE_MAXSYMBOLS, LzxConstants.MAINTREE_TABLEBITS,
+							                           bitbuf);
+							if(main_element < LzxConstants.NUM_CHARS)
+							{
+								/* literal: 0 to NUM_CHARS-1 */
+								window[window_posn++] = (byte)main_element;
+								this_run--;
+							}
+							else
+							{
+								/* match: NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
+								main_element -= LzxConstants.NUM_CHARS;
+								
+								match_length = main_element & LzxConstants.NUM_PRIMARY_LENGTHS;
+								if(match_length == LzxConstants.NUM_PRIMARY_LENGTHS)
+								{
+									length_footer = (int)ReadHuffSym(m_state.LENGTH_table, m_state.LENGTH_len,
+									                            LzxConstants.LENGTH_MAXSYMBOLS, LzxConstants.LENGTH_TABLEBITS,
+									                            bitbuf);
+									match_length += length_footer;
+								}
+								match_length += LzxConstants.MIN_MATCH;
+								
+								match_offset = main_element >> 3;
+								
+								if(match_offset > 2)
+								{
+									/* not repeated offset */
+									if(match_offset != 3)
+									{
+										extra = extra_bits[match_offset];
+										verbatim_bits = (int)bitbuf.ReadBits((byte)extra);
+										match_offset = (int)position_base[match_offset] - 2 + verbatim_bits;
+									}
+									else
+									{
+										match_offset = 1;
+									}
+									
+									/* update repeated offset LRU queue */
+									R2 = R1; R1 = R0; R0 = (uint)match_offset;
+								}
+								else if(match_offset == 0)
+								{
+									match_offset = (int)R0;
+								}
+								else if(match_offset == 1)
+								{
+									match_offset = (int)R1;
+									R1 = R0; R0 = (uint)match_offset;
+								}
+								else /* match_offset == 2 */
+								{
+									match_offset = (int)R2;
+									R2 = R0; R0 = (uint)match_offset;
+								}
+								
+								rundest = (int)window_posn;
+								this_run -= match_length;
+								
+								/* copy any wrapped around source data */
+								if(window_posn >= match_offset)
+								{
+									/* no wrap */
+									runsrc = rundest - match_offset;
+								}
+								else
+								{
+									runsrc = rundest + ((int)window_size - match_offset);
+									copy_length = match_offset - (int)window_posn;
+									if(copy_length < match_length)
+									{
+										match_length -= copy_length;
+										window_posn += (uint)copy_length;
+										while(copy_length-- > 0) window[rundest++] = window[runsrc++];
+										runsrc = 0;
+									}
+								}
+								window_posn += (uint)match_length;
+								
+								/* copy match data - no worries about destination wraps */
+								while(match_length-- > 0) window[rundest++] = window[runsrc++];
+							}
+						}
+						break;
+					
+					case LzxConstants.BLOCKTYPE.ALIGNED:
+						while(this_run > 0)
+						{
+							main_element = (int)ReadHuffSym(m_state.MAINTREE_table, m_state.MAINTREE_len,
+							                           				  LzxConstants.MAINTREE_MAXSYMBOLS, LzxConstants.MAINTREE_TABLEBITS,
+							                           				  bitbuf);
+							
+							if(main_element < LzxConstants.NUM_CHARS)
+							{
+								/* literal 0 to NUM_CHARS-1 */
+								window[window_posn++] = (byte)main_element;
+								this_run--;
+							}
+							else
+							{
+								/* match: NUM_CHARS + ((slot<<3) | length_header (3 bits)) */
+								main_element -= LzxConstants.NUM_CHARS;
+								
+								match_length = main_element & LzxConstants.NUM_PRIMARY_LENGTHS;
+								if(match_length == LzxConstants.NUM_PRIMARY_LENGTHS)
+								{
+									length_footer = (int)ReadHuffSym(m_state.LENGTH_table, m_state.LENGTH_len,
+									                            	 LzxConstants.LENGTH_MAXSYMBOLS, LzxConstants.LENGTH_TABLEBITS,
+									                            	 bitbuf);
+									match_length += length_footer;
+								}
+								match_length += LzxConstants.MIN_MATCH;
+								
+								match_offset = main_element >> 3;
+								
+								if(match_offset > 2)
+								{
+									/* not repeated offset */
+									extra = extra_bits[match_offset];
+									match_offset = (int)position_base[match_offset] - 2;
+									if(extra > 3)
+									{
+										/* verbatim and aligned bits */
+										extra -= 3;
+										verbatim_bits = (int)bitbuf.ReadBits((byte)extra);
+										match_offset += (verbatim_bits << 3);
+										aligned_bits = (int)ReadHuffSym(m_state.ALIGNED_table, m_state.ALIGNED_len,
+										                           LzxConstants.ALIGNED_MAXSYMBOLS, LzxConstants.ALIGNED_TABLEBITS,
+										                           bitbuf);
+										match_offset += aligned_bits;
+									}
+									else if(extra == 3)
+									{
+										/* aligned bits only */
+										aligned_bits = (int)ReadHuffSym(m_state.ALIGNED_table, m_state.ALIGNED_len,
+										                           LzxConstants.ALIGNED_MAXSYMBOLS, LzxConstants.ALIGNED_TABLEBITS,
+										                           bitbuf);
+										match_offset += aligned_bits;
+									}
+									else if (extra > 0) /* extra==1, extra==2 */
+									{
+										/* verbatim bits only */
+										verbatim_bits = (int)bitbuf.ReadBits((byte)extra);
+										match_offset += verbatim_bits;
+									}
+									else /* extra == 0 */
+									{
+										/* ??? */
+										match_offset = 1;
+									}
+									
+									/* update repeated offset LRU queue */
+									R2 = R1; R1 = R0; R0 = (uint)match_offset;
+								}
+								else if( match_offset == 0)
+								{
+									match_offset = (int)R0;
+								}
+								else if(match_offset == 1)
+								{
+									match_offset = (int)R1;
+									R1 = R0; R0 = (uint)match_offset;
+								}
+								else /* match_offset == 2 */
+								{
+									match_offset = (int)R2;
+									R2 = R0; R0 = (uint)match_offset;
+								}
+								
+								rundest = (int)window_posn;
+								this_run -= match_length;
+								
+								/* copy any wrapped around source data */
+								if(window_posn >= match_offset)
+								{
+									/* no wrap */
+									runsrc = rundest - match_offset;
+								}
+								else
+								{
+									runsrc = rundest + ((int)window_size - match_offset);
+									copy_length = match_offset - (int)window_posn;
+									if(copy_length < match_length)
+									{
+										match_length -= copy_length;
+										window_posn += (uint)copy_length;
+										while(copy_length-- > 0) window[rundest++] = window[runsrc++];
+										runsrc = 0;
+									}
+								}
+								window_posn += (uint)match_length;
+								
+								/* copy match data - no worries about destination wraps */
+								while(match_length-- > 0) window[rundest++] = window[runsrc++];
+							}
+						}
+						break;
+						
+					case LzxConstants.BLOCKTYPE.UNCOMPRESSED:
+						if((inData.Position + this_run) > endpos) return -1; //TODO throw proper exception
+						byte[] temp_buffer = new byte[this_run];
+						inData.Read(temp_buffer, 0, this_run);
+						temp_buffer.CopyTo(window, (int)window_posn);
+						window_posn += (uint)this_run;
+						break;
+						
+					default:
+						return -1; //TODO throw proper exception
+					}
+				}
+			}
+			
+			if(togo != 0) return -1; //TODO throw proper exception
+			int start_window_pos = (int)window_posn;
+			if(start_window_pos == 0) start_window_pos = (int)window_size;
+			start_window_pos -= outLen;
+			outData.Write(window, start_window_pos, outLen);
+			
+			m_state.window_posn = window_posn;
+			m_state.R0 = R0;
+			m_state.R1 = R1;
+			m_state.R2 = R2;
+			
+			// TODO finish intel E8 decoding
+			/* intel E8 decoding */
+			if((m_state.frames_read++ < 32768) && m_state.intel_filesize != 0)
+			{
+				if(outLen <= 6 || m_state.intel_started == 0)
+				{
+					m_state.intel_curpos += outLen;
+				}
+				else
+				{
+					int dataend = outLen - 10;
+					uint curpos = (uint)m_state.intel_curpos;
+					
+					m_state.intel_curpos = (int)curpos + outLen;
+					
+					while(outData.Position < dataend)
+					{
+						if(outData.ReadByte() != 0xE8) { curpos++; continue; }
+					}
+				}
+				return -1;
+			}
+			return 0;
+		}
+		
+		// READ_LENGTHS(table, first, last)
+		// if(lzx_read_lens(LENTABLE(table), first, last, bitsleft))
+		//   return ERROR (ILLEGAL_DATA)
+		// 
+		
+		// TODO make returns throw exceptions
+		private int MakeDecodeTable(uint nsyms, uint nbits, byte[] length, ushort[] table)
+		{
+			ushort sym;
+			uint leaf;
+			byte bit_num = 1;
+			uint fill;
+			uint pos			= 0; /* the current position in the decode table */
+			uint table_mask		= (uint)(1 << (int)nbits);
+			uint bit_mask		= table_mask >> 1; /* don't do 0 length codes */
+			uint next_symbol	= bit_mask;	/* base of allocation for long codes */
+			
+			/* fill entries for codes short enough for a direct mapping */
+			while (bit_num <= nbits )
+			{
+				for(sym = 0; sym < nsyms; sym++)
+				{
+					if(length[sym] == bit_num)
+					{
+						leaf = pos;
+						
+						if((pos += bit_mask) > table_mask) return 1; /* table overrun */
+						
+						/* fill all possible lookups of this symbol with the symbol itself */
+						fill = bit_mask;
+						while(fill-- > 0) table[leaf++] = sym;
+					}
+				}
+				bit_mask >>= 1;
+				bit_num++;
+			}
+			
+			/* if there are any codes longer than nbits */
+			if(pos != table_mask)
+			{
+				/* clear the remainder of the table */
+				for(sym = (ushort)pos; sym < table_mask; sym++) table[sym] = 0;
+				
+				/* give ourselves room for codes to grow by up to 16 more bits */
+				pos <<= 16;
+				table_mask <<= 16;
+				bit_mask = 1 << 15;
+				
+				while(bit_num <= 16)
+				{
+					for(sym = 0; sym < nsyms; sym++)
+					{
+						if(length[sym] == bit_num)
+						{
+							leaf = pos >> 16;
+							for(fill = 0; fill < bit_num - nbits; fill++)
+							{
+								/* if this path hasn't been taken yet, 'allocate' two entries */
+								if(table[leaf] == 0)
+								{
+									table[(next_symbol << 1)] = 0;
+									table[(next_symbol << 1) + 1] = 0;
+									table[leaf] = (ushort)(next_symbol++);
+								}
+								/* follow the path and select either left or right for next bit */
+								leaf = (uint)(table[leaf] << 1);
+								if(((pos >> (int)(15-fill)) & 1) == 1) leaf++;
+							}
+							table[leaf] = sym;
+							
+							if((pos += bit_mask) > table_mask) return 1;
+						}
+					}
+					bit_mask >>= 1;
+					bit_num++;
+				}
+			}
+			
+			/* full talbe? */
+			if(pos == table_mask) return 0;
+			
+			/* either erroneous table, or all elements are 0 - let's find out. */
+			for(sym = 0; sym < nsyms; sym++) if(length[sym] != 0) return 1;
+			return 0;
+		}
+		
+		// TODO throw exceptions instead of returns
+		private void ReadLengths(byte[] lens, uint first, uint last, BitBuffer bitbuf)
+		{
+			uint x, y;
+			int z;
+			
+			// hufftbl pointer here?
+			
+			for(x = 0; x < 20; x++)
+			{
+				y = bitbuf.ReadBits(4);
+				m_state.PRETREE_len[x] = (byte)y;
+			}
+			MakeDecodeTable(LzxConstants.PRETREE_MAXSYMBOLS, LzxConstants.PRETREE_TABLEBITS,
+			                m_state.PRETREE_len, m_state.PRETREE_table);
+			
+			for(x = first; x < last;)
+			{
+				z = (int)ReadHuffSym(m_state.PRETREE_table, m_state.PRETREE_len,
+				                LzxConstants.PRETREE_MAXSYMBOLS, LzxConstants.PRETREE_TABLEBITS, bitbuf);
+				if(z == 17)
+				{
+					y = bitbuf.ReadBits(4); y += 4;
+					while(y-- != 0) lens[x++] = 0;
+				}
+				else if(z == 18)
+				{
+					y = bitbuf.ReadBits(5); y += 20;
+					while(y-- != 0) lens[x++] = 0;
+				}
+				else if(z == 19)
+				{
+					y = bitbuf.ReadBits(1); y += 4;
+					z = (int)ReadHuffSym(m_state.PRETREE_table, m_state.PRETREE_len,
+				                LzxConstants.PRETREE_MAXSYMBOLS, LzxConstants.PRETREE_TABLEBITS, bitbuf);
+					z = lens[x] - z; if(z < 0) z += 17;
+					while(y-- != 0) lens[x++] = (byte)z;
+				}
+				else
+				{
+					z = lens[x] - z; if(z < 0) z += 17;
+					lens[x++] = (byte)z;
+				}
+			}
+		}
+		
+		private uint ReadHuffSym(ushort[] table, byte[] lengths, uint nsyms, uint nbits, BitBuffer bitbuf)
+		{
+			uint i, j;
+			bitbuf.EnsureBits(16);
+			if((i = table[bitbuf.PeekBits((byte)nbits)]) >= nsyms)
+			{
+				j = (uint)(1 << (int)((sizeof(uint)*8) - nbits));
+				do
+				{
+					j >>= 1; i <<= 1; i |= (bitbuf.GetBuffer() & j) != 0 ? (uint)1 : 0;
+					if(j == 0) return 0; // TODO throw proper exception
+				} while((i = table[i]) >= nsyms);
+			}
+			j = lengths[i];
+			bitbuf.RemoveBits((byte)j);
+			
+			return i;
+		}
+		
+		#region Our BitBuffer Class
+		private class BitBuffer
+		{
+			uint buffer;
+			byte bitsleft;
+			Stream byteStream;
+			
+			public BitBuffer(Stream stream)
+			{
+				byteStream = stream;
+				InitBitStream();
+			}
+			
+			public void InitBitStream()
+			{
+				buffer = 0;
+				bitsleft = 0;
+			}
+			
+			public void EnsureBits(byte bits)
+			{
+				while(bitsleft < bits) {
+					int lo = (byte)byteStream.ReadByte();
+					int hi = (byte)byteStream.ReadByte();
+                    //int amount2shift = sizeof(uint)*8 - 16 - bitsleft;
+					buffer |= (uint)(((hi << 8) | lo) << (sizeof(uint)*8 - 16 - bitsleft));
+					bitsleft += 16;
+				}
+			}
+			
+			public uint PeekBits(byte bits)
+			{
+				return (buffer >> ((sizeof(uint)*8) - bits));
+			}
+			
+			public void RemoveBits(byte bits)
+			{
+				buffer <<= bits;
+				bitsleft -= bits;
+			}
+			
+			public uint ReadBits(byte bits)
+			{
+				uint ret = 0;
+				
+				if(bits > 0)
+				{
+					EnsureBits(bits);
+					ret = PeekBits(bits);
+					RemoveBits(bits);
+				}
+				
+				return ret;
+			}
+			
+			public uint GetBuffer()
+			{
+				return buffer;
+			}
+			
+			public byte GetBitsLeft()
+			{
+				return bitsleft;
+			}
+		}
+		#endregion
+		
+		struct LzxState {
+			public uint						R0, R1, R2;			/* for the LRU offset system				*/
+			public ushort					main_elements;		/* number of main tree elements				*/
+			public int						header_read;		/* have we started decoding at all yet? 	*/
+			public LzxConstants.BLOCKTYPE	block_type;			/* type of this block						*/
+			public uint						block_length;		/* uncompressed length of this block 		*/
+			public uint						block_remaining;	/* uncompressed bytes still left to decode	*/
+			public uint						frames_read;		/* the number of CFDATA blocks processed	*/
+			public int						intel_filesize;		/* magic header value used for transform	*/
+			public int						intel_curpos;		/* current offset in transform space		*/
+			public int						intel_started;		/* have we seen any translateable data yet?	*/
+			
+			public ushort[]		PRETREE_table;
+			public byte[]		PRETREE_len;
+			public ushort[]		MAINTREE_table;
+			public byte[]		MAINTREE_len;
+			public ushort[]		LENGTH_table;
+			public byte[]		LENGTH_len;
+			public ushort[]		ALIGNED_table;
+			public byte[]		ALIGNED_len;
+			
+			// NEEDED MEMBERS
+			// CAB actualsize
+			// CAB window
+			// CAB window_size
+			// CAB window_posn
+			public uint		actual_size;
+			public byte[]	window;
+			public uint		window_size;
+			public uint		window_posn;
+		}
+	}
+	
+	/* CONSTANTS */
+	struct LzxConstants {
+		public const ushort MIN_MATCH =				2;
+		public const ushort MAX_MATCH =				257;
+		public const ushort NUM_CHARS =				256;
+		public enum BLOCKTYPE {
+			INVALID = 0,
+			VERBATIM = 1,
+			ALIGNED = 2,
+			UNCOMPRESSED = 3
+		}
+		public const ushort PRETREE_NUM_ELEMENTS =	20;
+		public const ushort ALIGNED_NUM_ELEMENTS =	8;
+		public const ushort NUM_PRIMARY_LENGTHS =	7;
+		public const ushort NUM_SECONDARY_LENGTHS = 249;
+		
+		public const ushort PRETREE_MAXSYMBOLS = 	PRETREE_NUM_ELEMENTS;
+		public const ushort PRETREE_TABLEBITS =		6;
+		public const ushort MAINTREE_MAXSYMBOLS = 	NUM_CHARS + 50*8;
+		public const ushort MAINTREE_TABLEBITS = 	12;
+		public const ushort LENGTH_MAXSYMBOLS = 	NUM_SECONDARY_LENGTHS + 1;
+		public const ushort LENGTH_TABLEBITS =		12;
+		public const ushort ALIGNED_MAXSYMBOLS = 	ALIGNED_NUM_ELEMENTS;
+		public const ushort ALIGNED_TABLEBITS = 	7;
+				
+		public const ushort LENTABLE_SAFETY =		64;
+	}
+	
+	/* EXCEPTIONS */
+	class UnsupportedWindowSizeRange : Exception
+	{
+	}
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Content/ResourceContentManager.cs b/MonoGame.Framework/Content/ResourceContentManager.cs
new file mode 100644
index 00000000000..37afa9913e7
--- /dev/null
+++ b/MonoGame.Framework/Content/ResourceContentManager.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Resources;
+
+namespace Microsoft.Xna.Framework.Content
+{
+    public class ResourceContentManager : ContentManager
+    {
+        private ResourceManager resource;
+
+        public ResourceContentManager(IServiceProvider servicesProvider, ResourceManager resource)
+            : base(servicesProvider)
+        {
+            if (resource == null)
+            {
+                throw new ArgumentNullException("resource");
+            }
+            this.resource = resource;
+        }
+
+        protected override System.IO.Stream OpenStream(string assetName)
+        {
+            object obj = this.resource.GetObject(assetName);
+            if (obj == null)
+            {
+                throw new ContentLoadException("Resource not found");
+            }
+            if (!(obj is byte[]))
+            {
+                throw new ContentLoadException("Resource is not in binary format");
+            }
+            return new MemoryStream(obj as byte[]);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Curve.cs b/MonoGame.Framework/Curve.cs
new file mode 100644
index 00000000000..bea6e0ccbfc
--- /dev/null
+++ b/MonoGame.Framework/Curve.cs
@@ -0,0 +1,338 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.ComponentModel;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Contains a collection of <see cref="CurveKey"/> points in 2D space and provides methods for evaluating features of the curve they define.
+    /// </summary>
+    // TODO : [TypeConverter(typeof(ExpandableObjectConverter))]
+    [DataContract]
+    public class Curve
+    {
+        #region Private Fields
+
+        private CurveLoopType _preLoop;
+        private CurveLoopType _postLoop;
+        private CurveKeyCollection _keys;
+
+        #endregion
+
+        #region Public Properties
+
+        /// <summary>
+        /// Returns <c>true</c> if this curve is constant (has zero or one points); <c>false</c> otherwise.
+        /// </summary>
+        [DataMember]
+        public bool IsConstant
+        {
+            get { return this._keys.Count <= 1; }
+        }
+
+        /// <summary>
+        /// Defines how to handle weighting values that are less than the first control point in the curve.
+        /// </summary>
+        [DataMember]
+        public CurveLoopType PreLoop
+        {
+            get { return this._preLoop; }
+            set { this._preLoop = value; }
+        }
+
+        /// <summary>
+        /// Defines how to handle weighting values that are greater than the last control point in the curve.
+        /// </summary>
+        [DataMember]
+        public CurveLoopType PostLoop
+        {
+            get { return this._postLoop; }
+            set { this._postLoop = value; }
+        }
+
+        /// <summary>
+        /// The collection of curve keys.
+        /// </summary>
+        [DataMember]
+        public CurveKeyCollection Keys
+        {
+            get { return this._keys; }
+        }
+
+        #endregion
+
+        #region Public Constructors
+
+        /// <summary>
+        /// Constructs a curve.
+        /// </summary>
+        public Curve()
+        {
+            this._keys = new CurveKeyCollection();
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Creates a copy of this curve.
+        /// </summary>
+        /// <returns>A copy of this curve.</returns>
+        public Curve Clone()
+        {
+            Curve curve = new Curve();
+
+            curve._keys = this._keys.Clone();
+            curve._preLoop = this._preLoop;
+            curve._postLoop = this._postLoop;
+
+            return curve;
+        }
+
+        /// <summary>
+        /// Evaluate the value at a position of this <see cref="Curve"/>.
+        /// </summary>
+        /// <param name="position">The position on this <see cref="Curve"/>.</param>
+        /// <returns>Value at the position on this <see cref="Curve"/>.</returns>
+        public float Evaluate(float position)
+        {
+            if (_keys.Count == 0)
+            {
+            	return 0f;
+            }
+						
+            if (_keys.Count == 1)
+            {
+            	return _keys[0].Value;
+            }
+			
+            CurveKey first = _keys[0];
+            CurveKey last = _keys[_keys.Count - 1];
+
+            if (position < first.Position)
+            {
+                switch (this.PreLoop)
+                {
+                    case CurveLoopType.Constant:
+                        //constant
+                        return first.Value;
+
+                    case CurveLoopType.Linear:
+                        // linear y = a*x +b with a tangeant of last point
+                        return first.Value - first.TangentIn * (first.Position - position);
+
+                    case CurveLoopType.Cycle:
+                        //start -> end / start -> end
+                        int cycle = GetNumberOfCycle(position);
+                        float virtualPos = position - (cycle * (last.Position - first.Position));
+                        return GetCurvePosition(virtualPos);
+
+                    case CurveLoopType.CycleOffset:
+                        //make the curve continue (with no step) so must up the curve each cycle of delta(value)
+                        cycle = GetNumberOfCycle(position);
+                        virtualPos = position - (cycle * (last.Position - first.Position));
+                        return (GetCurvePosition(virtualPos) + cycle * (last.Value - first.Value));
+
+                    case CurveLoopType.Oscillate:
+                        //go back on curve from end and target start 
+                        // start-> end / end -> start
+                        cycle = GetNumberOfCycle(position);
+                        if (0 == cycle % 2f)//if pair
+                            virtualPos = position - (cycle * (last.Position - first.Position));
+                        else
+                            virtualPos = last.Position - position + first.Position + (cycle * (last.Position - first.Position));
+                        return GetCurvePosition(virtualPos);
+                }
+            }
+            else if (position > last.Position)
+            {
+                int cycle;
+                switch (this.PostLoop)
+                {
+                    case CurveLoopType.Constant:
+                        //constant
+                        return last.Value;
+
+                    case CurveLoopType.Linear:
+                        // linear y = a*x +b with a tangeant of last point
+                        return last.Value + first.TangentOut * (position - last.Position);
+
+                    case CurveLoopType.Cycle:
+                        //start -> end / start -> end
+                        cycle = GetNumberOfCycle(position);
+                        float virtualPos = position - (cycle * (last.Position - first.Position));
+                        return GetCurvePosition(virtualPos);
+
+                    case CurveLoopType.CycleOffset:
+                        //make the curve continue (with no step) so must up the curve each cycle of delta(value)
+                        cycle = GetNumberOfCycle(position);
+                        virtualPos = position - (cycle * (last.Position - first.Position));
+                        return (GetCurvePosition(virtualPos) + cycle * (last.Value - first.Value));
+
+                    case CurveLoopType.Oscillate:
+                        //go back on curve from end and target start 
+                        // start-> end / end -> start
+                        cycle = GetNumberOfCycle(position);
+                        virtualPos = position - (cycle * (last.Position - first.Position));
+                        if (0 == cycle % 2f)//if pair
+                            virtualPos = position - (cycle * (last.Position - first.Position));
+                        else
+                            virtualPos = last.Position - position + first.Position + (cycle * (last.Position - first.Position));
+                        return GetCurvePosition(virtualPos);
+                }
+            }
+
+            //in curve
+            return GetCurvePosition(position);
+        }
+
+        /// <summary>
+        /// Computes tangents for all keys in the collection.
+        /// </summary>
+        /// <param name="tangentType">The tangent type for both in and out.</param>
+		public void ComputeTangents (CurveTangent tangentType)
+		{
+		    ComputeTangents(tangentType, tangentType);
+		}
+		
+        /// <summary>
+        /// Computes tangents for all keys in the collection.
+        /// </summary>
+        /// <param name="tangentInType">The tangent in-type. <see cref="CurveKey.TangentIn"/> for more details.</param>
+        /// <param name="tangentOutType">The tangent out-type. <see cref="CurveKey.TangentOut"/> for more details.</param>
+		public void ComputeTangents(CurveTangent tangentInType, CurveTangent tangentOutType)
+		{
+            for (var i = 0; i < Keys.Count; ++i)
+            {
+                ComputeTangent(i, tangentInType, tangentOutType);
+            }
+		}
+
+        /// <summary>
+        /// Computes tangent for the specific key in the collection.
+        /// </summary>
+        /// <param name="keyIndex">The index of a key in the collection.</param>
+        /// <param name="tangentType">The tangent type for both in and out.</param>
+        public void ComputeTangent(int keyIndex, CurveTangent tangentType)
+        {
+            ComputeTangent(keyIndex, tangentType, tangentType);
+        }
+
+        /// <summary>
+        /// Computes tangent for the specific key in the collection.
+        /// </summary>
+        /// <param name="keyIndex">The index of key in the collection.</param>
+        /// <param name="tangentInType">The tangent in-type. <see cref="CurveKey.TangentIn"/> for more details.</param>
+        /// <param name="tangentOutType">The tangent out-type. <see cref="CurveKey.TangentOut"/> for more details.</param>
+        public void ComputeTangent(int keyIndex, CurveTangent tangentInType, CurveTangent tangentOutType)
+        {
+            // See http://msdn.microsoft.com/en-us/library/microsoft.xna.framework.curvetangent.aspx
+
+            var key = _keys[keyIndex];
+
+            float p0, p, p1;
+            p0 = p = p1 = key.Position;
+
+            float v0, v, v1;
+            v0 = v = v1 = key.Value;
+
+            if ( keyIndex > 0 )
+            {
+                p0 = _keys[keyIndex - 1].Position;
+                v0 = _keys[keyIndex - 1].Value;
+            }
+
+            if (keyIndex < _keys.Count-1)
+            {
+                p1 = _keys[keyIndex + 1].Position;
+                v1 = _keys[keyIndex + 1].Value;
+            }
+
+            switch (tangentInType)
+            {
+                case CurveTangent.Flat:
+                    key.TangentIn = 0;
+                    break;
+                case CurveTangent.Linear:
+                    key.TangentIn = v - v0;
+                    break;
+                case CurveTangent.Smooth:
+                    var pn = p1 - p0;
+                    if (Math.Abs(pn) < float.Epsilon)
+                        key.TangentIn = 0;
+                    else
+                        key.TangentIn = (v1 - v0) * ((p - p0) / pn);
+                    break;
+            }
+
+            switch (tangentOutType)
+            {
+                case CurveTangent.Flat:
+                    key.TangentOut = 0;
+                    break;
+                case CurveTangent.Linear:
+                    key.TangentOut = v1 - v;
+                    break;
+                case CurveTangent.Smooth:
+                    var pn = p1 - p0;
+                    if (Math.Abs(pn) < float.Epsilon)
+                        key.TangentOut = 0;
+                    else
+                        key.TangentOut = (v1 - v0) * ((p1 - p) / pn);
+                    break;
+            }
+        }
+
+	    #endregion
+
+        #region Private Methods
+
+        private int GetNumberOfCycle(float position)
+        {
+            float cycle = (position - _keys[0].Position) / (_keys[_keys.Count - 1].Position - _keys[0].Position);
+            if (cycle < 0f)
+                cycle--;
+            return (int)cycle;
+        }
+
+        private float GetCurvePosition(float position)
+        {
+            //only for position in curve
+            CurveKey prev = this._keys[0];
+            CurveKey next;
+            for (int i = 1; i < this._keys.Count; ++i)
+            {
+                next = this.Keys[i];
+                if (next.Position >= position)
+                {
+                    if (prev.Continuity == CurveContinuity.Step)
+                    {
+                        if (position >= 1f)
+                        {
+                            return next.Value;
+                        }
+                        return prev.Value;
+                    }
+                    float t = (position - prev.Position) / (next.Position - prev.Position);//to have t in [0,1]
+                    float ts = t * t;
+                    float tss = ts * t;
+                    //After a lot of search on internet I have found all about spline function
+                    // and bezier (phi'sss ancien) but finaly use hermite curve 
+                    //http://en.wikipedia.org/wiki/Cubic_Hermite_spline
+                    //P(t) = (2*t^3 - 3t^2 + 1)*P0 + (t^3 - 2t^2 + t)m0 + (-2t^3 + 3t^2)P1 + (t^3-t^2)m1
+                    //with P0.value = prev.value , m0 = prev.tangentOut, P1= next.value, m1 = next.TangentIn
+                    return (2 * tss - 3 * ts + 1f) * prev.Value + (tss - 2 * ts + t) * prev.TangentOut + (3 * ts - 2 * tss) * next.Value + (tss - ts) * next.TangentIn;
+                }
+                prev = next;
+            }
+            return 0f;
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/CurveContinuity.cs b/MonoGame.Framework/CurveContinuity.cs
new file mode 100644
index 00000000000..3ad42299c8a
--- /dev/null
+++ b/MonoGame.Framework/CurveContinuity.cs
@@ -0,0 +1,21 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Defines the continuity of keys on a <see cref="Curve"/>.
+    /// </summary>
+    public enum CurveContinuity
+    {
+        /// <summary>
+        /// Interpolation can be used between this key and the next.
+        /// </summary>
+        Smooth,
+        /// <summary>
+        /// Interpolation cannot be used. A position between the two points returns this point.
+        /// </summary>
+        Step
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/CurveKey.cs b/MonoGame.Framework/CurveKey.cs
new file mode 100644
index 00000000000..06b485e0d8d
--- /dev/null
+++ b/MonoGame.Framework/CurveKey.cs
@@ -0,0 +1,201 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.ComponentModel;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Key point on the <see cref="Curve"/>.
+    /// </summary>
+    // TODO : [TypeConverter(typeof(ExpandableObjectConverter))]
+    [DataContract]
+    public class CurveKey : IEquatable<CurveKey>, IComparable<CurveKey>
+    {
+        #region Private Fields
+
+        private CurveContinuity _continuity;
+        private readonly float _position;
+        private float _tangentIn;
+        private float _tangentOut;
+        private float _value;
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets or sets the indicator whether the segment between this point and the next point on the curve is discrete or continuous.
+        /// </summary>
+        [DataMember]
+        public CurveContinuity Continuity
+        {
+            get { return this._continuity; }
+            set { this._continuity = value; }
+        }
+
+        /// <summary>
+        /// Gets a position of the key on the curve.
+        /// </summary>
+        [DataMember]
+        public float Position
+        {
+            get { return this._position; }
+        }
+
+        /// <summary>
+        /// Gets or sets a tangent when approaching this point from the previous point on the curve.
+        /// </summary>
+        [DataMember]
+        public float TangentIn
+        {
+            get { return this._tangentIn; }
+            set { this._tangentIn = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets a tangent when leaving this point to the next point on the curve.
+        /// </summary>
+        [DataMember]
+        public float TangentOut
+        {
+            get { return this._tangentOut; }
+            set { this._tangentOut = value; }
+        }
+
+        /// <summary>
+        /// Gets a value of this point.
+        /// </summary>
+        [DataMember]
+        public float Value
+        {
+            get { return this._value; }
+            set { this._value = value; }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates a new instance of <see cref="CurveKey"/> class with position: 0 and value: 0.
+        /// </summary>
+        public CurveKey() : this(0, 0)
+        {
+            // This parameterless constructor is needed for correct serialization of CurveKeyCollection and CurveKey.
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="CurveKey"/> class.
+        /// </summary>
+        /// <param name="position">Position on the curve.</param>
+        /// <param name="value">Value of the control point.</param>
+        public CurveKey(float position, float value)
+            : this(position, value, 0, 0, CurveContinuity.Smooth)
+        {
+
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="CurveKey"/> class.
+        /// </summary>
+        /// <param name="position">Position on the curve.</param>
+        /// <param name="value">Value of the control point.</param>
+        /// <param name="tangentIn">Tangent approaching point from the previous point on the curve.</param>
+        /// <param name="tangentOut">Tangent leaving point toward next point on the curve.</param>
+        public CurveKey(float position, float value, float tangentIn, float tangentOut)
+            : this(position, value, tangentIn, tangentOut, CurveContinuity.Smooth)
+        {
+
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="CurveKey"/> class.
+        /// </summary>
+        /// <param name="position">Position on the curve.</param>
+        /// <param name="value">Value of the control point.</param>
+        /// <param name="tangentIn">Tangent approaching point from the previous point on the curve.</param>
+        /// <param name="tangentOut">Tangent leaving point toward next point on the curve.</param>
+        /// <param name="continuity">Indicates whether the curve is discrete or continuous.</param>
+        public CurveKey(float position, float value, float tangentIn, float tangentOut, CurveContinuity continuity)
+        {
+            this._position = position;
+            this._value = value;
+            this._tangentIn = tangentIn;
+            this._tangentOut = tangentOut;
+            this._continuity = continuity;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// 
+        /// Compares whether two <see cref="CurveKey"/> instances are not equal.
+        /// </summary>
+        /// <param name="value1"><see cref="CurveKey"/> instance on the left of the not equal sign.</param>
+        /// <param name="value2"><see cref="CurveKey"/> instance on the right of the not equal sign.</param>
+        /// <returns><c>true</c> if the instances are not equal; <c>false</c> otherwise.</returns>	
+        public static bool operator !=(CurveKey value1, CurveKey value2)
+        {
+            return !(value1 == value2);
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="CurveKey"/> instances are equal.
+        /// </summary>
+        /// <param name="value1"><see cref="CurveKey"/> instance on the left of the equal sign.</param>
+        /// <param name="value2"><see cref="CurveKey"/> instance on the right of the equal sign.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(CurveKey value1, CurveKey value2)
+        {
+            if (object.Equals(value1, null))
+                return object.Equals(value2, null);
+
+            if (object.Equals(value2, null))
+                return object.Equals(value1, null);
+
+            return (value1._position == value2._position)
+                && (value1._value == value2._value)
+                && (value1._tangentIn == value2._tangentIn)
+                && (value1._tangentOut == value2._tangentOut)
+                && (value1._continuity == value2._continuity);
+        }
+
+        /// <summary>
+        /// Creates a copy of this key.
+        /// </summary>
+        /// <returns>A copy of this key.</returns>
+        public CurveKey Clone()
+        {
+            return new CurveKey(this._position, this._value, this._tangentIn, this._tangentOut, this._continuity);
+        }
+
+        #region Inherited Methods
+
+        public int CompareTo(CurveKey other)
+        {
+            return this._position.CompareTo(other._position);
+        }
+
+        public bool Equals(CurveKey other)
+        {
+            return (this == other);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return (obj as CurveKey) != null && Equals((CurveKey)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return this._position.GetHashCode() ^ this._value.GetHashCode() ^ this._tangentIn.GetHashCode() ^
+                this._tangentOut.GetHashCode() ^ this._continuity.GetHashCode();
+        } 
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/CurveKeyCollection.cs b/MonoGame.Framework/CurveKeyCollection.cs
new file mode 100644
index 00000000000..eb2f6adf347
--- /dev/null
+++ b/MonoGame.Framework/CurveKeyCollection.cs
@@ -0,0 +1,200 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// The collection of the <see cref="CurveKey"/> elements and a part of the <see cref="Curve"/> class.
+    /// </summary>
+    // TODO : [TypeConverter(typeof(ExpandableObjectConverter))]
+    [DataContract]
+    public class CurveKeyCollection : ICollection<CurveKey>
+    {
+        #region Private Fields
+
+        private readonly List<CurveKey> _keys;
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Indexer.
+        /// </summary>
+        /// <param name="index">The index of key in this collection.</param>
+        /// <returns><see cref="CurveKey"/> at <paramref name="index"/> position.</returns>
+        [DataMember(Name = "Items")]
+        public CurveKey this[int index]
+        {
+            get { return _keys[index]; }
+            set
+            {
+                if (value == null)
+                    throw new ArgumentNullException();
+
+                if (index >= _keys.Count)
+                    throw new IndexOutOfRangeException();
+
+                if (_keys[index].Position == value.Position)
+                    _keys[index] = value;
+                else
+                {
+                    _keys.RemoveAt(index);
+                    _keys.Add(value);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns the count of keys in this collection.
+        /// </summary>
+        [DataMember]
+        public int Count
+        {
+            get { return _keys.Count; }
+        }
+
+        /// <summary>
+        /// Returns false because it is not a read-only collection.
+        /// </summary>
+        [DataMember]
+        public bool IsReadOnly
+        {
+            get { return false; }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates a new instance of <see cref="CurveKeyCollection"/> class.
+        /// </summary>
+        public CurveKeyCollection()
+        {
+            _keys = new List<CurveKey>();
+        }
+
+        #endregion
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return _keys.GetEnumerator();
+        }
+
+
+        /// <summary>
+        /// Adds a key to this collection.
+        /// </summary>
+        /// <param name="item">New key for the collection.</param>
+        /// <exception cref="ArgumentNullException">Throws if <paramref name="item"/> is null.</exception>
+        /// <remarks>The new key would be added respectively to a position of that key and the position of other keys.</remarks>
+        public void Add(CurveKey item)
+        {
+            if (item == null)
+                throw new ArgumentNullException("item");
+
+            if (_keys.Count == 0)
+            {
+                this._keys.Add(item);
+                return;
+            }
+
+            for (int i = 0; i < this._keys.Count; i++)
+            {
+                if (item.Position < this._keys[i].Position)
+                {
+                    this._keys.Insert(i, item);
+                    return;
+                }
+            }
+
+            this._keys.Add(item);
+        }
+
+        /// <summary>
+        /// Removes all keys from this collection.
+        /// </summary>
+        public void Clear()
+        {
+            _keys.Clear();
+        }
+
+        /// <summary>
+        /// Creates a copy of this collection.
+        /// </summary>
+        /// <returns>A copy of this collection.</returns>
+        public CurveKeyCollection Clone()
+        {
+            CurveKeyCollection ckc = new CurveKeyCollection();
+            foreach (CurveKey key in this._keys)
+                ckc.Add(key);
+            return ckc;
+        }
+
+        /// <summary>
+        /// Determines whether this collection contains a specific key.
+        /// </summary>
+        /// <param name="item">The key to locate in this collection.</param>
+        /// <returns><c>true</c> if the key is found; <c>false</c> otherwise.</returns>
+        public bool Contains(CurveKey item)
+        {
+            return _keys.Contains(item);
+        }
+
+        /// <summary>
+        /// Copies the keys of this collection to an array, starting at the array index provided.
+        /// </summary>
+        /// <param name="array">Destination array where elements will be copied.</param>
+        /// <param name="arrayIndex">The zero-based index in the array to start copying from.</param>
+        public void CopyTo(CurveKey[] array, int arrayIndex)
+        {
+            _keys.CopyTo(array, arrayIndex);
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through the collection.
+        /// </summary>
+        /// <returns>An enumerator for the <see cref="CurveKeyCollection"/>.</returns>
+        public IEnumerator<CurveKey> GetEnumerator()
+        {
+            return _keys.GetEnumerator();
+        }
+
+        /// <summary>
+        /// Finds element in the collection and returns its index.
+        /// </summary>
+        /// <param name="item">Element for the search.</param>
+        /// <returns>Index of the element; or -1 if item is not found.</returns>
+        public int IndexOf(CurveKey item)
+        {
+            return _keys.IndexOf(item);
+        }
+
+        /// <summary>
+        /// Removes element at the specified index.
+        /// </summary>
+        /// <param name="index">The index which element will be removed.</param>
+        public void RemoveAt(int index)
+        {
+            _keys.RemoveAt(index);
+        }
+        
+        /// <summary>
+        /// Removes specific element.
+        /// </summary>
+        /// <param name="item">The element</param>
+        /// <returns><c>true</c> if item is successfully removed; <c>false</c> otherwise. This method also returns <c>false</c> if item was not found.</returns>
+        public bool Remove(CurveKey item)
+        {
+            return _keys.Remove(item);
+        }
+    }
+}
diff --git a/MonoGame.Framework/CurveLoopType.cs b/MonoGame.Framework/CurveLoopType.cs
new file mode 100644
index 00000000000..3dcb66be787
--- /dev/null
+++ b/MonoGame.Framework/CurveLoopType.cs
@@ -0,0 +1,35 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Defines how the <see cref="Curve"/> value is determined for position before first point or after the end point on the <see cref="Curve"/>.
+    /// </summary>
+    public enum CurveLoopType
+    {
+        /// <summary>
+        /// The value of <see cref="Curve"/> will be evaluated as first point for positions before the beginning and end point for positions after the end.
+        /// </summary>
+        Constant,
+        /// <summary>
+        /// The positions will wrap around from the end to beginning of the <see cref="Curve"/> for determined the value.
+        /// </summary>
+        Cycle,
+        /// <summary>
+        /// The positions will wrap around from the end to beginning of the <see cref="Curve"/>.
+        /// The value will be offset by the difference between the values of first and end <see cref="CurveKey"/> multiplied by the wrap amount.
+        /// If the position is before the beginning of the <see cref="Curve"/> the difference will be subtracted from its value; otherwise the difference will be added.
+        /// </summary>
+        CycleOffset,
+        /// <summary>
+        /// The value at the end of the <see cref="Curve"/> act as an offset from the same side of the <see cref="Curve"/> toward the opposite side.
+        /// </summary>
+        Oscillate,
+        /// <summary>
+        /// The linear interpolation will be performed for determined the value. 
+        /// </summary>
+        Linear
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/CurveTangent.cs b/MonoGame.Framework/CurveTangent.cs
new file mode 100644
index 00000000000..d986f371b97
--- /dev/null
+++ b/MonoGame.Framework/CurveTangent.cs
@@ -0,0 +1,25 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Defines the different tangent types to be calculated for <see cref="CurveKey"/> points in a <see cref="Curve"/>.
+    /// </summary>
+	public enum CurveTangent
+	{
+        /// <summary>
+        /// The tangent which always has a value equal to zero. 
+        /// </summary>
+		Flat,
+        /// <summary>
+        /// The tangent which contains a difference between current tangent value and the tangent value from the previous <see cref="CurveKey"/>. 
+        /// </summary>
+		Linear,
+        /// <summary>
+        /// The smoouth tangent which contains the inflection between <see cref="CurveKey.TangentIn"/> and <see cref="CurveKey.TangentOut"/> by taking into account the values of both neighbors of the <see cref="CurveKey"/>.
+        /// </summary>
+		Smooth
+	}
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Design/Vector2TypeConverter.cs b/MonoGame.Framework/Design/Vector2TypeConverter.cs
new file mode 100644
index 00000000000..b96f37b3656
--- /dev/null
+++ b/MonoGame.Framework/Design/Vector2TypeConverter.cs
@@ -0,0 +1,72 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.ComponentModel;
+using System.Globalization;
+
+namespace Microsoft.Xna.Framework.Design
+{
+    public class Vector2TypeConverter : TypeConverter
+    {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            if (VectorConversion.CanConvertTo(context, destinationType))
+                return true;
+            if (destinationType == typeof(string))
+                return true;
+
+            return base.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            var vec = (Vector2)value;
+
+            if (VectorConversion.CanConvertTo(context, destinationType))
+            {
+                var vec4 = new Vector4(vec.X, vec.Y, 0.0f, 0.0f);
+                return VectorConversion.ConvertToFromVector4(context, culture, vec4, destinationType);
+            }
+
+            if (destinationType == typeof(string))
+            {
+                var terms = new string[2];
+                terms[0] = vec.X.ToString("R", culture);
+                terms[1] = vec.Y.ToString("R", culture);
+
+                return string.Join(culture.TextInfo.ListSeparator + " ", terms);
+            }
+
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+        {
+            if (sourceType == typeof(string))
+                return true;
+
+            return base.CanConvertFrom(context, sourceType);
+        }
+
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            var sourceType = value.GetType();
+            var vec = Vector2.Zero;
+
+            if (sourceType == typeof(string))
+            {
+                var str = (string)value;
+                var words = str.Split(culture.TextInfo.ListSeparator.ToCharArray());
+
+                vec.X = float.Parse(words[0], culture);
+                vec.Y = float.Parse(words[1], culture);
+
+                return vec;
+            }
+
+            return base.ConvertFrom(context, culture, value);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Design/Vector3TypeConverter.cs b/MonoGame.Framework/Design/Vector3TypeConverter.cs
new file mode 100644
index 00000000000..0920696a255
--- /dev/null
+++ b/MonoGame.Framework/Design/Vector3TypeConverter.cs
@@ -0,0 +1,74 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.ComponentModel;
+using System.Globalization;
+
+namespace Microsoft.Xna.Framework.Design
+{
+    public class Vector3TypeConverter : TypeConverter
+    {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            if (VectorConversion.CanConvertTo(context, destinationType))
+                return true;
+            if (destinationType == typeof(string))
+                return true;
+
+            return base.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            var vec = (Vector3)value;
+
+            if (VectorConversion.CanConvertTo(context, destinationType))
+            {
+                var vec4 = new Vector4(vec.X, vec.Y, vec.Z, 0.0f);
+                return VectorConversion.ConvertToFromVector4(context, culture, vec4, destinationType);
+            }
+
+            if (destinationType == typeof(string))
+            {                
+                var terms = new string[3];
+                terms[0] = vec.X.ToString("R", culture);
+                terms[1] = vec.Y.ToString("R", culture);
+                terms[2] = vec.Z.ToString("R", culture);
+
+                return string.Join(culture.TextInfo.ListSeparator + " ", terms);
+            }
+
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+        {
+            if (sourceType == typeof(string))
+                return true;
+
+            return base.CanConvertFrom(context, sourceType);
+        }
+
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            var sourceType = value.GetType();
+            var vec = Vector3.Zero;
+
+            if (sourceType == typeof(string))
+            {
+                var str = (string)value;
+                var words = str.Split(culture.TextInfo.ListSeparator.ToCharArray());
+
+                vec.X = float.Parse(words[0], culture);
+                vec.Y = float.Parse(words[1], culture);
+                vec.Z = float.Parse(words[2], culture);
+
+                return vec;
+            }
+
+            return base.ConvertFrom(context, culture, value);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Design/Vector4TypeConverter.cs b/MonoGame.Framework/Design/Vector4TypeConverter.cs
new file mode 100644
index 00000000000..3f5886b736d
--- /dev/null
+++ b/MonoGame.Framework/Design/Vector4TypeConverter.cs
@@ -0,0 +1,76 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.ComponentModel;
+using System.Globalization;
+
+namespace Microsoft.Xna.Framework.Design
+{
+    public class Vector4TypeConverter : TypeConverter
+    {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            if (VectorConversion.CanConvertTo(context, destinationType))
+                return true;
+            if (destinationType == typeof(string))
+                return true;
+
+            return base.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            var vec = (Vector4)value;
+
+            if (VectorConversion.CanConvertTo(context, destinationType))
+            {
+                return VectorConversion.ConvertToFromVector4(context, culture, vec, destinationType);
+            }
+
+            if (destinationType == typeof(string))
+            {
+                var terms = new string[4];
+                terms[0] = vec.X.ToString("R", culture);
+                terms[1] = vec.Y.ToString("R", culture);
+                terms[2] = vec.Z.ToString("R", culture);
+                terms[3] = vec.W.ToString("R", culture);
+
+                return string.Join(culture.TextInfo.ListSeparator + " ", terms);
+            }
+
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+        {
+            if (sourceType == typeof(string))
+                return true;
+
+            return base.CanConvertFrom(context, sourceType);
+        }
+
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            var sourceType = value.GetType();
+            var vec = Vector4.Zero;
+
+            if (sourceType == typeof(string))
+            {
+                var str = (string)value;
+                var words = str.Split(culture.TextInfo.ListSeparator.ToCharArray());
+
+                vec.X = float.Parse(words[0], culture);
+                vec.Y = float.Parse(words[1], culture);
+                vec.Z = float.Parse(words[2], culture);
+                vec.W = float.Parse(words[3], culture);
+
+                return vec;
+            }
+
+            return base.ConvertFrom(context, culture, value);
+        }
+    }
+}
+    
\ No newline at end of file
diff --git a/MonoGame.Framework/Design/VectorConversion.cs b/MonoGame.Framework/Design/VectorConversion.cs
new file mode 100644
index 00000000000..d1e972307e5
--- /dev/null
+++ b/MonoGame.Framework/Design/VectorConversion.cs
@@ -0,0 +1,46 @@
+using System;
+using System.ComponentModel;
+using System.Globalization;
+using Microsoft.Xna.Framework.Graphics.PackedVector;
+
+namespace Microsoft.Xna.Framework.Design
+{
+    internal static class VectorConversion
+    {
+        public static bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            if (destinationType == typeof(float))
+                return true;
+            if (destinationType == typeof(Vector2))
+                return true;
+            if (destinationType == typeof(Vector3))
+                return true;
+            if (destinationType == typeof(Vector4))
+                return true;
+            if (destinationType.GetInterface("IPackedVector") != null)
+                return true;
+
+            return false;
+        }
+
+        public static object ConvertToFromVector4(ITypeDescriptorContext context, CultureInfo culture, Vector4 value, Type destinationType)
+        {
+            if (destinationType == typeof(float))
+                return value.X;
+            if (destinationType == typeof(Vector2))
+                return new Vector2(value.X, value.Y);
+            if (destinationType == typeof(Vector3))
+                return new Vector3(value.X, value.Y, value.Z);
+            if (destinationType == typeof(Vector4))
+                return new Vector4(value.X, value.Y, value.Z, value.W);
+            if (destinationType.GetInterface("IPackedVector") != null)
+            {
+                var packedVec = (IPackedVector)Activator.CreateInstance(destinationType);
+                packedVec.PackFromVector4(value);
+                return packedVec;
+            }            
+
+            return null;
+        }         
+    }
+}
diff --git a/MonoGame.Framework/DesktopGL/GamerServices/Guide.cs b/MonoGame.Framework/DesktopGL/GamerServices/Guide.cs
new file mode 100644
index 00000000000..f3344d348ed
--- /dev/null
+++ b/MonoGame.Framework/DesktopGL/GamerServices/Guide.cs
@@ -0,0 +1,330 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+#region Using clause
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Runtime.Remoting.Messaging;
+
+using Microsoft.Xna.Framework.Net;
+
+
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	public static class Guide
+	{
+		private static bool isScreenSaverEnabled;
+		private static bool isTrialMode;
+		private static bool isVisible;
+		private static bool simulateTrialMode;		
+
+		delegate string ShowKeyboardInputDelegate(
+		 PlayerIndex player,           
+         string title,
+         string description,
+         string defaultText,
+		 bool usePasswordMode);
+
+		public static string ShowKeyboardInput(
+		 PlayerIndex player,           
+         string title,
+         string description,
+         string defaultText,
+		 bool usePasswordMode)
+		{
+            throw new NotImplementedException();
+		}
+
+		public static IAsyncResult BeginShowKeyboardInput (
+         PlayerIndex player,
+         string title,
+         string description,
+         string defaultText,
+         AsyncCallback callback,
+         Object state)
+		{
+			return BeginShowKeyboardInput(player, title, description, defaultText, callback, state, false );
+		}
+
+		public static IAsyncResult BeginShowKeyboardInput (
+         PlayerIndex player,
+         string title,
+         string description,
+         string defaultText,
+         AsyncCallback callback,
+         Object state,
+         bool usePasswordMode)
+		{
+            return BeginShowKeyboardInput(player, title, description, defaultText, callback, state, false );
+		}
+
+		public static string EndShowKeyboardInput (IAsyncResult result)
+        {
+            ShowKeyboardInputDelegate ski = (ShowKeyboardInputDelegate)result.AsyncState; 
+
+            return ski.EndInvoke(result);			
+		}
+
+		delegate Nullable<int> ShowMessageBoxDelegate( string title,
+         string text,
+         IEnumerable<string> buttons,
+         int focusButton,
+         MessageBoxIcon icon);
+
+		public static Nullable<int> ShowMessageBox( string title,
+         string text,
+         IEnumerable<string> buttons,
+         int focusButton,
+         MessageBoxIcon icon)
+        {
+            int? result = null;
+            IsVisible = true;
+
+            IsVisible = false;
+            return result;
+		}
+
+		public static IAsyncResult BeginShowMessageBox(
+         PlayerIndex player,
+         string title,
+         string text,
+         IEnumerable<string> buttons,
+         int focusButton,
+         MessageBoxIcon icon,
+         AsyncCallback callback,
+         Object state
+		)
+		{	
+            if (IsVisible)
+                throw new Exception("The function cannot be completed at this time: the Guide UI is already active. Wait until Guide.IsVisible is false before issuing this call.");
+
+            if (player != PlayerIndex.One)
+                throw new ArgumentOutOfRangeException("player", "Specified argument was out of the range of valid values.");
+            if (title == null)
+                throw new ArgumentNullException("title", "This string cannot be null or empty, and must be less than 256 characters long.");
+            if (text == null)
+                throw new ArgumentNullException("text", "This string cannot be null or empty, and must be less than 256 characters long.");
+            if (buttons == null)
+                throw new ArgumentNullException("buttons", "Value can not be null.");
+
+            ShowMessageBoxDelegate smb = ShowMessageBox;
+
+            return smb.BeginInvoke(title, text, buttons, focusButton, icon, callback, smb);		
+		}
+
+		public static IAsyncResult BeginShowMessageBox (
+         string title,
+         string text,
+         IEnumerable<string> buttons,
+         int focusButton,
+         MessageBoxIcon icon,
+         AsyncCallback callback,
+         Object state
+		)
+		{
+			return BeginShowMessageBox(PlayerIndex.One, title, text, buttons, focusButton, icon, callback, state);
+		}
+
+		public static Nullable<int> EndShowMessageBox (IAsyncResult result)
+        {
+            return ((ShowMessageBoxDelegate)result.AsyncState).EndInvoke(result);
+		}
+
+
+		public static void ShowMarketplace (PlayerIndex player )
+		{
+			
+		}
+
+		public static void Show ()
+		{
+			ShowSignIn(1, false);
+		}
+
+		public static void ShowSignIn (int paneCount, bool onlineOnly)
+		{
+			if ( paneCount != 1 && paneCount != 2 && paneCount != 4)
+			{
+				new ArgumentException("paneCount Can only be 1, 2 or 4 on Windows");
+				return;
+			}
+
+            Microsoft.Xna.Framework.GamerServices.MonoGameGamerServicesHelper.ShowSigninSheet();
+            if (GamerServicesComponent.LocalNetworkGamer == null)
+            {
+                GamerServicesComponent.LocalNetworkGamer = new LocalNetworkGamer();
+            }
+            else
+            {
+                GamerServicesComponent.LocalNetworkGamer.SignedInGamer.BeginAuthentication(null, null);
+            }
+		}
+
+		public static void ShowLeaderboard()
+		{
+            //if ( ( Gamer.SignedInGamers.Count > 0 ) && ( Gamer.SignedInGamers[0].IsSignedInToLive ) )
+            //{
+            //    // Lazy load it
+            //    if ( leaderboardController == null )
+            //    {			    	
+            //        leaderboardController = new GKLeaderboardViewController();
+            //    }
+
+            //    if (leaderboardController != null)			
+            //    {
+            //        leaderboardController.DidFinish += delegate(object sender, EventArgs e) 
+            //        {
+            //            leaderboardController.DismissModalViewControllerAnimated(true);
+            //            isVisible = false;
+            //        };
+
+            //        if (Window !=null)
+            //        {						
+            //            if(viewController == null)
+            //            {
+            //                viewController = new UIViewController();
+            //                Window.Add(viewController.View);
+            //                viewController.View.Hidden = true;
+            //            }
+
+            //            viewController.PresentModalViewController(leaderboardController, true);
+            //            isVisible = true;
+            //        }
+            //    }
+            //}
+		}
+
+		public static void ShowAchievements()
+		{
+            //if ( ( Gamer.SignedInGamers.Count > 0 ) && ( Gamer.SignedInGamers[0].IsSignedInToLive ) )
+            //{
+            //    // Lazy load it
+            //    if ( achievementController == null )
+            //    {
+            //        achievementController = new GKAchievementViewController();
+            //    }
+
+            //    if (achievementController != null)		
+            //    {					
+            //        achievementController.DidFinish += delegate(object sender, EventArgs e) 
+            //        {									 
+            //            leaderboardController.DismissModalViewControllerAnimated(true);
+            //            isVisible = false;
+            //        };
+
+            //        if (Window !=null)
+            //        {
+            //            if(viewController == null)
+            //            {
+            //                viewController = new UIViewController();
+            //                Window.Add(viewController.View);
+            //                viewController.View.Hidden = true;
+            //            }
+
+            //            viewController.PresentModalViewController(achievementController, true);						
+            //            isVisible = true;
+            //        }
+            //    }
+            //}
+		}
+
+		#region Properties
+		public static bool IsScreenSaverEnabled 
+		{ 
+			get
+			{
+				return isScreenSaverEnabled;
+			}
+			set
+			{
+				isScreenSaverEnabled = value;
+			}
+		}
+
+		public static bool IsTrialMode 
+		{ 
+			get
+			{
+                return simulateTrialMode || isTrialMode;
+			}
+		}
+
+		public static bool IsVisible 
+		{ 
+			get
+			{
+				return isVisible;
+			}
+			set
+			{
+				isVisible = value;
+			}
+		}
+
+		public static bool SimulateTrialMode 
+		{ 
+			get
+			{
+				return simulateTrialMode;
+			}
+			set
+			{
+				simulateTrialMode = value;
+			}
+		}
+
+		public static GameWindow Window 
+		{ 
+			get;
+			set;
+		}
+		#endregion
+
+        internal static void Initialise(Game game)
+        {
+            MonoGameGamerServicesHelper.Initialise(game);
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/DesktopGL/GamerServices/MonoGameGamerServicesHelper.cs b/MonoGame.Framework/DesktopGL/GamerServices/MonoGameGamerServicesHelper.cs
new file mode 100644
index 00000000000..5eb90df65be
--- /dev/null
+++ b/MonoGame.Framework/DesktopGL/GamerServices/MonoGameGamerServicesHelper.cs
@@ -0,0 +1,151 @@
+using System;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    internal class MonoGameGamerServicesHelper
+    {
+        private static MonoLiveGuide guide = null;
+
+
+
+        public static void ShowSigninSheet()
+        {
+            guide.Enabled = true;
+            guide.Visible = true;
+            Guide.IsVisible = true;
+        }
+
+        internal static void Initialise(Game game)
+        {
+            if (guide == null)
+            {
+                guide = new MonoLiveGuide(game);                
+                game.Components.Add(guide);
+            }
+        }}
+
+    internal class MonoLiveGuide : DrawableGameComponent
+    {
+        SpriteBatch spriteBatch;
+        Texture2D signInProgress;
+        Color alphaColor = new Color(128, 128, 128, 0);
+        byte startalpha = 0;
+
+        public MonoLiveGuide(Game game)
+            : base(game)
+        {
+            this.Enabled = false;
+            this.Visible = false;
+            //Guide.IsVisible = false;
+            this.DrawOrder = Int32.MaxValue;
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+        }
+
+        Texture2D Circle(GraphicsDevice graphics, int radius)
+        {
+            int aDiameter = radius * 2;
+            Vector2 aCenter = new Vector2(radius, radius);
+
+            Texture2D aCircle = new Texture2D(graphics, aDiameter, aDiameter, false, SurfaceFormat.Color);
+            Color[] aColors = new Color[aDiameter * aDiameter];
+
+            for (int i = 0; i < aColors.Length; i++)
+            {
+                int x = (i + 1) % aDiameter;
+                int y = (i + 1) / aDiameter;
+
+                Vector2 aDistance = new Vector2(Math.Abs(aCenter.X - x), Math.Abs(aCenter.Y - y));
+
+
+                if (Math.Sqrt((aDistance.X * aDistance.X) + (aDistance.Y * aDistance.Y)) > radius)
+                {
+                    aColors[i] = Color.Transparent;
+                }
+                else
+                {
+                    aColors[i] = Color.White;
+                }
+            }
+
+            aCircle.SetData<Color>(aColors);
+
+            return aCircle;
+        }
+
+        protected override void LoadContent()
+        {
+            spriteBatch = new SpriteBatch(this.Game.GraphicsDevice);
+
+            signInProgress = Circle(this.Game.GraphicsDevice, 10);
+
+            base.LoadContent();
+        }
+
+        protected override void UnloadContent()
+        {
+            base.UnloadContent();
+        }
+
+        public override void Draw(GameTime gameTime)
+        {
+            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend);
+
+            Vector2 center = new Vector2(this.Game.GraphicsDevice.PresentationParameters.BackBufferWidth / 2, this.Game.GraphicsDevice.PresentationParameters.BackBufferHeight - 100);
+            Vector2 loc = Vector2.Zero;
+            alphaColor.A = startalpha;
+            for (int i = 0; i < 12; i++)
+            {
+                float angle = (float)(i / 12.0 * Math.PI * 2);
+                loc = new Vector2(center.X + (float)Math.Cos(angle) * 50, center.Y + (float)Math.Sin(angle) * 50);
+                spriteBatch.Draw(signInProgress, loc, alphaColor);
+                alphaColor.A += 255 / 12;
+                if (alphaColor.A > 255) alphaColor.A = 0;
+            }
+            spriteBatch.End();
+            base.Draw(gameTime);
+        }
+
+        TimeSpan gt = TimeSpan.Zero;
+        TimeSpan last = TimeSpan.Zero;
+
+        public override void Update(GameTime gameTime)
+        {
+            if (gt == TimeSpan.Zero) gt = last = gameTime.TotalGameTime;
+
+            if ((gameTime.TotalGameTime - last).Milliseconds > 100)
+            {
+                last = gameTime.TotalGameTime;
+                startalpha += 255 / 12;
+            }
+
+            if ((gameTime.TotalGameTime - gt).TotalSeconds > 5) // close after 10 seconds
+            {
+                string strUsr = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
+
+                if (strUsr.Contains(@"\"))
+                {
+                    int idx = strUsr.IndexOf(@"\") + 1;
+                    strUsr = strUsr.Substring(idx, strUsr.Length - idx);
+                }
+
+                SignedInGamer sig = new SignedInGamer();
+                sig.DisplayName = strUsr;
+                sig.Gamertag = strUsr;
+
+                Gamer.SignedInGamers.Add(sig);
+
+                this.Visible = false;
+                this.Enabled = false;
+                //Guide.IsVisible = false;
+                gt = TimeSpan.Zero;
+            }
+            base.Update(gameTime);
+        }
+
+    }
+}
diff --git a/MonoGame.Framework/DesktopGL/GamerServices/SignedInGamer.cs b/MonoGame.Framework/DesktopGL/GamerServices/SignedInGamer.cs
new file mode 100644
index 00000000000..4955549043a
--- /dev/null
+++ b/MonoGame.Framework/DesktopGL/GamerServices/SignedInGamer.cs
@@ -0,0 +1,327 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+#region Statement
+using System;
+
+#endregion Statement
+
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    public class SignedInGamer : Gamer
+    {		
+		private AchievementCollection gamerAchievements;
+		private FriendCollection friendCollection;
+		
+		delegate void AuthenticationDelegate();
+		
+		public IAsyncResult BeginAuthentication(AsyncCallback callback, Object asyncState)
+		{
+			// Go off authenticate
+			AuthenticationDelegate ad = DoAuthentication; 
+			
+			return ad.BeginInvoke(callback, ad);
+		}
+		
+		public void EndAuthentication( IAsyncResult result )
+		{
+			AuthenticationDelegate ad = (AuthenticationDelegate)result.AsyncState; 
+			
+			ad.EndInvoke(result);
+		}
+		
+		private void DoAuthentication()
+		{
+				
+		}
+		
+		public SignedInGamer()
+		{
+			
+			var result = BeginAuthentication(null, null);	
+			EndAuthentication( result );
+		}
+		
+		private void AuthenticationCompletedCallback( IAsyncResult result )
+		{
+			EndAuthentication(result);	
+		}
+		
+		#region Methods
+		public FriendCollection GetFriends()
+		{
+			if(IsSignedInToLive)
+			{
+				if ( friendCollection == null )
+				{
+					friendCollection = new FriendCollection();
+				}
+								
+			}
+			
+			return friendCollection;
+		}
+		
+		public bool IsFriend (Gamer gamer)
+		{
+			if ( gamer == null ) 
+				throw new ArgumentNullException();
+			
+			if ( gamer.IsDisposed )
+				throw new ObjectDisposedException(gamer.ToString());	
+			
+			bool found = false;
+			foreach(FriendGamer f in friendCollection)
+			{
+				if ( f.Gamertag == gamer.Gamertag )
+				{
+					found = true;
+				}
+			}
+			return found;
+						
+		}
+		
+		delegate AchievementCollection GetAchievementsDelegate();
+		
+		public IAsyncResult BeginGetAchievements( AsyncCallback callback, Object asyncState)
+		{
+			// Go off and grab achievements
+			GetAchievementsDelegate gad = GetAchievements; 
+			
+			return gad.BeginInvoke(callback, gad);
+		}
+		
+		private void GetAchievementCompletedCallback( IAsyncResult result )
+		{
+			// get the delegate that was used to call that method
+			GetAchievementsDelegate gad = (GetAchievementsDelegate)result.AsyncState; 
+
+			// get the return value from that method call
+			gamerAchievements = gad.EndInvoke(result);
+		}
+		
+		public AchievementCollection EndGetAchievements( IAsyncResult result )
+		{
+			GetAchievementsDelegate gad = (GetAchievementsDelegate)result.AsyncState; 
+			
+			gamerAchievements = gad.EndInvoke(result);
+			
+			return gamerAchievements;
+		}
+		
+		public AchievementCollection GetAchievements()
+		{
+			if ( IsSignedInToLive )
+			{
+				if (gamerAchievements == null)
+				{
+					gamerAchievements = new AchievementCollection();
+				}
+								
+			}
+			return gamerAchievements;
+		}
+		
+		delegate void AwardAchievementDelegate(string achievementId, double percentageComplete);
+
+        public IAsyncResult BeginAwardAchievement(string achievementId, AsyncCallback callback, Object state)
+        {
+            return BeginAwardAchievement(achievementId, 100.0, callback, state);
+        }
+
+        public IAsyncResult BeginAwardAchievement(
+         string achievementId,
+		 double percentageComplete,
+         AsyncCallback callback,
+         Object state
+		)
+		{	
+			// Go off and award the achievement
+			AwardAchievementDelegate aad = DoAwardAchievement; 
+				
+			return aad.BeginInvoke(achievementId, percentageComplete, callback, aad);
+		}
+		
+		public void EndAwardAchievement(IAsyncResult result)
+		{
+			AwardAchievementDelegate aad = (AwardAchievementDelegate)result.AsyncState; 
+			
+			aad.EndInvoke(result);
+		}
+		
+		private void AwardAchievementCompletedCallback( IAsyncResult result )
+		{
+			EndAwardAchievement(result);	
+		}
+		
+		public void AwardAchievement( string achievementId )
+		{			
+			AwardAchievement(achievementId, 100.0f);
+		}
+		
+		public void DoAwardAchievement( string achievementId, double percentageComplete )
+		{			
+		}
+		
+		public void AwardAchievement( string achievementId, double percentageComplete )
+		{
+			if (IsSignedInToLive)
+			{
+				BeginAwardAchievement( achievementId, percentageComplete, AwardAchievementCompletedCallback, null );
+			}
+		}
+		
+		public void UpdateScore( string aCategory, long aScore )
+		{
+			if (IsSignedInToLive)
+			{				
+			}
+		}
+		
+		public void ResetAchievements()
+		{
+			if (IsSignedInToLive)
+			{				
+			}
+		}
+
+		#endregion
+			
+		#region Properties
+		public GameDefaults GameDefaults 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+		
+		public bool IsGuest 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+		
+		public bool IsSignedInToLive 
+		{ 
+			get
+			{
+				return false;
+			}
+		}
+		
+		public int PartySize 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+			set
+			{
+				throw new NotSupportedException();
+			}
+		}
+		
+        public PlayerIndex PlayerIndex
+        {
+            get
+            {
+                return PlayerIndex.One;
+            }
+        }
+		
+		public GamerPresence Presence 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+
+        GamerPrivileges _privileges = new GamerPrivileges();
+        public GamerPrivileges Privileges
+        {
+            get
+            {
+                return _privileges;
+            }
+        }
+		#endregion
+		
+		
+		protected virtual void OnSignedIn(SignedInEventArgs e)
+		{
+            EventHelpers.Raise(this, SignedIn, e);
+        }
+		
+		protected virtual void OnSignedOut(SignedOutEventArgs e)
+		{
+            EventHelpers.Raise(this, SignedOut, e);
+		}
+
+		
+		#region Events
+		public static event EventHandler<SignedInEventArgs> SignedIn;
+		
+		public static event EventHandler<SignedOutEventArgs> SignedOut;
+		#endregion
+    }
+	
+	public class SignedInEventArgs : EventArgs
+	{
+		public SignedInEventArgs ( SignedInGamer gamer )
+		{
+			
+		}
+	}
+	
+	public class SignedOutEventArgs : EventArgs
+	{
+		public SignedOutEventArgs (SignedInGamer gamer )
+		{
+			
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/DisplayOrientation.cs b/MonoGame.Framework/DisplayOrientation.cs
new file mode 100644
index 00000000000..bf4a7956282
--- /dev/null
+++ b/MonoGame.Framework/DisplayOrientation.cs
@@ -0,0 +1,40 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Defines the orientation of the display.
+    /// </summary>
+    [Flags]
+    public enum DisplayOrientation
+    {
+        /// <summary>
+        /// The default orientation.
+        /// </summary>
+        Default = 0,
+        /// <summary>
+        /// The display is rotated counterclockwise into a landscape orientation. Width is greater than height.
+        /// </summary>
+        LandscapeLeft = 1,
+        /// <summary>
+        /// The display is rotated clockwise into a landscape orientation. Width is greater than height.
+        /// </summary>
+        LandscapeRight = 2,
+        /// <summary>
+        /// The display is rotated as portrait, where height is greater than width.
+        /// </summary>
+        Portrait = 4,
+        /// <summary>
+        /// The display is rotated as inverted portrait, where height is greater than width.
+        /// </summary>
+        PortraitDown = 8,
+        /// <summary>
+        /// Unknown display orientation.
+        /// </summary>
+        Unknown = 16
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/DrawableGameComponent.cs b/MonoGame.Framework/DrawableGameComponent.cs
new file mode 100644
index 00000000000..bad81578c80
--- /dev/null
+++ b/MonoGame.Framework/DrawableGameComponent.cs
@@ -0,0 +1,79 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework
+{
+    public class DrawableGameComponent : GameComponent, IDrawable
+    {
+        private bool _initialized;
+        private int _drawOrder;
+        private bool _visible = true;
+
+        public Graphics.GraphicsDevice GraphicsDevice
+        {
+            get { return this.Game.GraphicsDevice; } 
+        }
+
+        public int DrawOrder
+        {
+            get { return _drawOrder; }
+            set
+            {
+                if (_drawOrder != value)
+                {
+                    _drawOrder = value;
+                    OnDrawOrderChanged(this, EventArgs.Empty);
+                }
+            }
+        }
+
+        public bool Visible
+        {
+            get { return _visible; }
+            set
+            {
+                if (_visible != value)
+                {
+                    _visible = value;
+                    OnVisibleChanged(this, EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler<EventArgs> DrawOrderChanged;
+        public event EventHandler<EventArgs> VisibleChanged;
+
+        public DrawableGameComponent(Game game)
+            : base(game)
+        {
+        }
+
+        public override void Initialize()
+        {
+            if (!_initialized)
+            {
+                _initialized = true;
+                LoadContent();
+            }
+        }
+
+        protected virtual void LoadContent() { }
+
+        protected virtual void UnloadContent () { }
+
+        public virtual void Draw(GameTime gameTime) { }
+
+        protected virtual void OnVisibleChanged(object sender, EventArgs args)
+        {
+            EventHelpers.Raise(sender, VisibleChanged, args);
+        }
+
+        protected virtual void OnDrawOrderChanged(object sender, EventArgs args)
+        {
+            EventHelpers.Raise(sender, DrawOrderChanged, args);
+        }
+    }
+}
diff --git a/MonoGame.Framework/EventHelpers.cs b/MonoGame.Framework/EventHelpers.cs
new file mode 100644
index 00000000000..05fb5c3e8c4
--- /dev/null
+++ b/MonoGame.Framework/EventHelpers.cs
@@ -0,0 +1,45 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Provides helper methods to make it easier
+    /// to safely raise events.
+    /// </summary>
+    internal static class EventHelpers
+    {
+        /// <summary>
+        /// Safely raises an event by storing a copy of the event's delegate
+        /// in the <paramref name="handler"/> parameter and checking it for
+        /// null before invoking it.
+        /// </summary>
+        /// <typeparam name="TEventArgs"></typeparam>
+        /// <param name="sender">The object raising the event.</param>
+        /// <param name="handler"><see cref="EventHandler{TEventArgs}"/> to be invoked</param>
+        /// <param name="e">The <typeparamref name="TEventArgs"/> passed to <see cref="EventHandler{TEventArgs}"/></param>
+        internal static void Raise<TEventArgs>(object sender, EventHandler<TEventArgs> handler, TEventArgs e)
+            where TEventArgs : EventArgs
+        {
+            if (handler != null)
+                handler(sender, e);
+        }
+
+        /// <summary>
+        /// Safely raises an event by storing a copy of the event's delegate
+        /// in the <paramref name="handler"/> parameter and checking it for
+        /// null before invoking it.
+        /// </summary>
+        /// <param name="sender">The object raising the event.</param>
+        /// <param name="handler"><see cref="EventHandler"/> to be invoked</param>
+        /// <param name="e">The <see cref="EventArgs"/> passed to <see cref="EventHandler"/></param>
+        internal static void Raise(object sender, EventHandler handler, EventArgs e)
+        {
+            if (handler != null)
+                handler(sender, e);
+        }
+    }
+}
diff --git a/MonoGame.Framework/FrameworkDispatcher.cs b/MonoGame.Framework/FrameworkDispatcher.cs
new file mode 100644
index 00000000000..ca3f6369f93
--- /dev/null
+++ b/MonoGame.Framework/FrameworkDispatcher.cs
@@ -0,0 +1,45 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Audio;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Helper class for processing internal framework events.
+    /// </summary>
+    /// <remarks>
+    /// If you use <see cref="Game"/> class, <see cref="Update()"/> is called automatically.
+    /// Otherwise you must call it as part of your game loop.
+    /// </remarks>
+    public static class FrameworkDispatcher
+    {
+        private static bool _initialized = false;
+
+        /// <summary>
+        /// Processes framework events.
+        /// </summary>
+        public static void Update()
+        {
+            if (!_initialized)
+                Initialize();
+
+            DoUpdate();
+        }
+
+        private static void DoUpdate()
+        {
+            DynamicSoundEffectInstanceManager.UpdatePlayingInstances();
+            SoundEffectInstancePool.Update();
+            Microphone.UpdateMicrophones();
+        }
+
+        private static void Initialize()
+        {
+            _initialized = true;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/FrameworkResources.cs b/MonoGame.Framework/FrameworkResources.cs
new file mode 100644
index 00000000000..8440f357622
--- /dev/null
+++ b/MonoGame.Framework/FrameworkResources.cs
@@ -0,0 +1,15 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework
+{
+    internal static class FrameworkResources
+    {
+        #region Error strings
+
+        internal const string ResourceCreationWhenDeviceIsNull = "The GraphicsDevice must not be null when creating new resources.";
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Game.cs b/MonoGame.Framework/Game.cs
new file mode 100644
index 00000000000..95ecdbeebbe
--- /dev/null
+++ b/MonoGame.Framework/Game.cs
@@ -0,0 +1,1035 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+#if WINDOWS_UAP
+using System.Threading.Tasks;
+using Windows.ApplicationModel.Activation;
+#endif
+using Microsoft.Xna.Framework.Audio;
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input.Touch;
+
+
+namespace Microsoft.Xna.Framework
+{
+    public partial class Game : IDisposable
+    {
+        private GameComponentCollection _components;
+        private GameServiceContainer _services;
+        private ContentManager _content;
+        internal GamePlatform Platform;
+
+        private SortingFilteringCollection<IDrawable> _drawables =
+            new SortingFilteringCollection<IDrawable>(
+                d => d.Visible,
+                (d, handler) => d.VisibleChanged += handler,
+                (d, handler) => d.VisibleChanged -= handler,
+                (d1 ,d2) => Comparer<int>.Default.Compare(d1.DrawOrder, d2.DrawOrder),
+                (d, handler) => d.DrawOrderChanged += handler,
+                (d, handler) => d.DrawOrderChanged -= handler);
+
+        private SortingFilteringCollection<IUpdateable> _updateables =
+            new SortingFilteringCollection<IUpdateable>(
+                u => u.Enabled,
+                (u, handler) => u.EnabledChanged += handler,
+                (u, handler) => u.EnabledChanged -= handler,
+                (u1, u2) => Comparer<int>.Default.Compare(u1.UpdateOrder, u2.UpdateOrder),
+                (u, handler) => u.UpdateOrderChanged += handler,
+                (u, handler) => u.UpdateOrderChanged -= handler);
+
+        private IGraphicsDeviceManager _graphicsDeviceManager;
+        private IGraphicsDeviceService _graphicsDeviceService;
+
+        private bool _initialized = false;
+        private bool _isFixedTimeStep = true;
+
+        private TimeSpan _targetElapsedTime = TimeSpan.FromTicks(166667); // 60fps
+        private TimeSpan _inactiveSleepTime = TimeSpan.FromSeconds(0.02);
+
+        private TimeSpan _maxElapsedTime = TimeSpan.FromMilliseconds(500);
+
+        private bool _shouldExit;
+        private bool _suppressDraw;
+
+        partial void PlatformConstruct();       
+
+        public Game()
+        {
+            _instance = this;
+
+            LaunchParameters = new LaunchParameters();
+            _services = new GameServiceContainer();
+            _components = new GameComponentCollection();
+            _content = new ContentManager(_services);
+
+            Platform = GamePlatform.PlatformCreate(this);
+            Platform.Activated += OnActivated;
+            Platform.Deactivated += OnDeactivated;
+            _services.AddService(typeof(GamePlatform), Platform);
+
+            // Calling Update() for first time initializes some systems
+            FrameworkDispatcher.Update();
+
+            // Allow some optional per-platform construction to occur too.
+            PlatformConstruct();
+
+        }
+
+        ~Game()
+        {
+            Dispose(false);
+        }
+
+		[System.Diagnostics.Conditional("DEBUG")]
+		internal void Log(string Message)
+		{
+			if (Platform != null) Platform.Log(Message);
+		}
+
+        #region IDisposable Implementation
+
+        private bool _isDisposed;
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+            EventHelpers.Raise(this, Disposed, EventArgs.Empty);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_isDisposed)
+            {
+                if (disposing)
+                {
+                    // Dispose loaded game components
+                    for (int i = 0; i < _components.Count; i++)
+                    {
+                        var disposable = _components[i] as IDisposable;
+                        if (disposable != null)
+                            disposable.Dispose();
+                    }
+                    _components = null;
+
+                    if (_content != null)
+                    {
+                        _content.Dispose();
+                        _content = null;
+                    }
+
+                    if (_graphicsDeviceManager != null)
+                    {
+                        (_graphicsDeviceManager as GraphicsDeviceManager).Dispose();
+                        _graphicsDeviceManager = null;
+                    }
+
+                    if (Platform != null)
+                    {
+                        Platform.Activated -= OnActivated;
+                        Platform.Deactivated -= OnDeactivated;
+                        _services.RemoveService(typeof(GamePlatform));
+
+                        Platform.Dispose();
+                        Platform = null;
+                    }
+
+                    ContentTypeReaderManager.ClearTypeCreators();
+
+                    if (SoundEffect._systemState == SoundEffect.SoundSystemState.Initialized)
+                        SoundEffect.PlatformShutdown();
+                }
+#if ANDROID
+                Activity = null;
+#endif
+                _isDisposed = true;
+                _instance = null;
+            }
+        }
+
+        [System.Diagnostics.DebuggerNonUserCode]
+        private void AssertNotDisposed()
+        {
+            if (_isDisposed)
+            {
+                string name = GetType().Name;
+                throw new ObjectDisposedException(
+                    name, string.Format("The {0} object was used after being Disposed.", name));
+            }
+        }
+
+        #endregion IDisposable Implementation
+
+        #region Properties
+
+#if ANDROID
+        [CLSCompliant(false)]
+        public static AndroidGameActivity Activity { get; internal set; }
+#endif
+        private static Game _instance = null;
+        internal static Game Instance { get { return Game._instance; } }
+
+        public LaunchParameters LaunchParameters { get; private set; }
+
+        public GameComponentCollection Components
+        {
+            get { return _components; }
+        }
+
+        public TimeSpan InactiveSleepTime
+        {
+            get { return _inactiveSleepTime; }
+            set
+            {
+                if (value < TimeSpan.Zero)
+                    throw new ArgumentOutOfRangeException("The time must be positive.", default(Exception));
+
+                _inactiveSleepTime = value;
+            }
+        }
+
+        /// <summary>
+        /// The maximum amount of time we will frameskip over and only perform Update calls with no Draw calls.
+        /// MonoGame extension.
+        /// </summary>
+        public TimeSpan MaxElapsedTime
+        {
+            get { return _maxElapsedTime; }
+            set
+            {
+                if (value < TimeSpan.Zero)
+                    throw new ArgumentOutOfRangeException("The time must be positive.", default(Exception));
+                if (value < _targetElapsedTime)
+                    throw new ArgumentOutOfRangeException("The time must be at least TargetElapsedTime", default(Exception));
+
+                _maxElapsedTime = value;
+            }
+        }
+
+        public bool IsActive
+        {
+            get { return Platform.IsActive; }
+        }
+
+        public bool IsMouseVisible
+        {
+            get { return Platform.IsMouseVisible; }
+            set { Platform.IsMouseVisible = value; }
+        }
+
+        public TimeSpan TargetElapsedTime
+        {
+            get { return _targetElapsedTime; }
+            set
+            {
+                // Give GamePlatform implementations an opportunity to override
+                // the new value.
+                value = Platform.TargetElapsedTimeChanging(value);
+
+                if (value <= TimeSpan.Zero)
+                    throw new ArgumentOutOfRangeException(
+                        "The time must be positive and non-zero.", default(Exception));
+
+                if (value != _targetElapsedTime)
+                {
+                    _targetElapsedTime = value;
+                    Platform.TargetElapsedTimeChanged();
+                }
+            }
+        }
+
+        public bool IsFixedTimeStep
+        {
+            get { return _isFixedTimeStep; }
+            set { _isFixedTimeStep = value; }
+        }
+
+        public GameServiceContainer Services {
+            get { return _services; }
+        }
+
+        public ContentManager Content
+        {
+            get { return _content; }
+            set
+            {
+                if (value == null)
+                    throw new ArgumentNullException();
+
+                _content = value;
+            }
+        }
+
+        public GraphicsDevice GraphicsDevice
+        {
+            get
+            {
+                if (_graphicsDeviceService == null)
+                {
+                    _graphicsDeviceService = (IGraphicsDeviceService)
+                        Services.GetService(typeof(IGraphicsDeviceService));
+
+                    if (_graphicsDeviceService == null)
+                        throw new InvalidOperationException("No Graphics Device Service");
+                }
+                return _graphicsDeviceService.GraphicsDevice;
+            }
+        }
+
+        [CLSCompliant(false)]
+        public GameWindow Window
+        {
+            get { return Platform.Window; }
+        }
+
+        #endregion Properties
+
+        #region Internal Properties
+
+        // FIXME: Internal members should be eliminated.
+        // Currently Game.Initialized is used by the Mac game window class to
+        // determine whether to raise DeviceResetting and DeviceReset on
+        // GraphicsDeviceManager.
+        internal bool Initialized
+        {
+            get { return _initialized; }
+        }
+
+        #endregion Internal Properties
+
+        #region Events
+
+        public event EventHandler<EventArgs> Activated;
+        public event EventHandler<EventArgs> Deactivated;
+        public event EventHandler<EventArgs> Disposed;
+        public event EventHandler<EventArgs> Exiting;
+
+#if WINDOWS_UAP
+        [CLSCompliant(false)]
+        public ApplicationExecutionState PreviousExecutionState { get; internal set; }
+#endif
+
+        #endregion
+
+        #region Public Methods
+
+#if IOS
+        [Obsolete("This platform's policy does not allow programmatically closing.", true)]
+#endif
+        public void Exit()
+        {
+            _shouldExit = true;
+            _suppressDraw = true;
+        }
+
+        public void ResetElapsedTime()
+        {
+            Platform.ResetElapsedTime();
+            _gameTimer.Reset();
+            _gameTimer.Start();
+            _accumulatedElapsedTime = TimeSpan.Zero;
+            _gameTime.ElapsedGameTime = TimeSpan.Zero;
+            _previousTicks = 0L;
+        }
+
+        public void SuppressDraw()
+        {
+            _suppressDraw = true;
+        }
+        
+        public void RunOneFrame()
+        {
+            if (Platform == null)
+                return;
+
+            if (!Platform.BeforeRun())
+                return;
+
+            if (!_initialized)
+            {
+                DoInitialize ();
+                _gameTimer = Stopwatch.StartNew();
+                _initialized = true;
+            }
+
+            BeginRun();            
+
+            //Not quite right..
+            Tick ();
+
+            EndRun ();
+
+        }
+
+        public void Run()
+        {
+            Run(Platform.DefaultRunBehavior);
+        }
+
+        public void Run(GameRunBehavior runBehavior)
+        {
+            AssertNotDisposed();
+            if (!Platform.BeforeRun())
+            {
+                BeginRun();
+                _gameTimer = Stopwatch.StartNew();
+                return;
+            }
+
+            if (!_initialized) {
+                DoInitialize ();
+                _initialized = true;
+            }
+
+            BeginRun();
+            _gameTimer = Stopwatch.StartNew();
+            switch (runBehavior)
+            {
+            case GameRunBehavior.Asynchronous:
+                Platform.AsyncRunLoopEnded += Platform_AsyncRunLoopEnded;
+                Platform.StartRunLoop();
+                break;
+            case GameRunBehavior.Synchronous:
+                // XNA runs one Update even before showing the window
+                DoUpdate(new GameTime());
+
+                Platform.RunLoop();
+                EndRun();
+				DoExiting();
+                break;
+            default:
+                throw new ArgumentException(string.Format(
+                    "Handling for the run behavior {0} is not implemented.", runBehavior));
+            }
+        }
+
+        private TimeSpan _accumulatedElapsedTime;
+        private readonly GameTime _gameTime = new GameTime();
+        private Stopwatch _gameTimer;
+        private long _previousTicks = 0;
+        private int _updateFrameLag;
+#if WINDOWS_UAP
+        private readonly object _locker = new object();
+#endif
+
+        public void Tick()
+        {
+            // NOTE: This code is very sensitive and can break very badly
+            // with even what looks like a safe change.  Be sure to test 
+            // any change fully in both the fixed and variable timestep 
+            // modes across multiple devices and platforms.
+
+        RetryTick:
+
+            if (!IsActive && (InactiveSleepTime.TotalMilliseconds >= 1.0))
+            {
+#if WINDOWS_UAP
+                lock (_locker)
+                    System.Threading.Monitor.Wait(_locker, (int)InactiveSleepTime.TotalMilliseconds);
+#else
+                System.Threading.Thread.Sleep((int)InactiveSleepTime.TotalMilliseconds);
+#endif
+            }
+
+            // Advance the accumulated elapsed time.
+            var currentTicks = _gameTimer.Elapsed.Ticks;
+            _accumulatedElapsedTime += TimeSpan.FromTicks(currentTicks - _previousTicks);
+            _previousTicks = currentTicks;
+
+            if (IsFixedTimeStep && _accumulatedElapsedTime < TargetElapsedTime)
+            {
+#if WINDOWS && !DESKTOPGL
+                // Sleep for as long as possible without overshooting the update time
+                var sleepTime = (TargetElapsedTime - _accumulatedElapsedTime).TotalMilliseconds;
+                MonoGame.Utilities.TimerHelper.SleepForNoMoreThan(sleepTime);
+#endif
+                // Keep looping until it's time to perform the next update
+                goto RetryTick;
+            }
+
+            // Do not allow any update to take longer than our maximum.
+            if (_accumulatedElapsedTime > _maxElapsedTime)
+                _accumulatedElapsedTime = _maxElapsedTime;
+
+            if (IsFixedTimeStep)
+            {
+                _gameTime.ElapsedGameTime = TargetElapsedTime;
+                var stepCount = 0;
+
+                // Perform as many full fixed length time steps as we can.
+                while (_accumulatedElapsedTime >= TargetElapsedTime && !_shouldExit)
+                {
+                    _gameTime.TotalGameTime += TargetElapsedTime;
+                    _accumulatedElapsedTime -= TargetElapsedTime;
+                    ++stepCount;
+
+                    DoUpdate(_gameTime);
+                }
+
+                //Every update after the first accumulates lag
+                _updateFrameLag += Math.Max(0, stepCount - 1);
+
+                //If we think we are running slowly, wait until the lag clears before resetting it
+                if (_gameTime.IsRunningSlowly)
+                {
+                    if (_updateFrameLag == 0)
+                        _gameTime.IsRunningSlowly = false;
+                }
+                else if (_updateFrameLag >= 5)
+                {
+                    //If we lag more than 5 frames, start thinking we are running slowly
+                    _gameTime.IsRunningSlowly = true;
+                }
+
+                //Every time we just do one update and one draw, then we are not running slowly, so decrease the lag
+                if (stepCount == 1 && _updateFrameLag > 0)
+                    _updateFrameLag--;
+
+                // Draw needs to know the total elapsed time
+                // that occured for the fixed length updates.
+                _gameTime.ElapsedGameTime = TimeSpan.FromTicks(TargetElapsedTime.Ticks * stepCount);
+            }
+            else
+            {
+                // Perform a single variable length update.
+                _gameTime.ElapsedGameTime = _accumulatedElapsedTime;
+                _gameTime.TotalGameTime += _accumulatedElapsedTime;
+                _accumulatedElapsedTime = TimeSpan.Zero;
+
+                DoUpdate(_gameTime);
+            }
+
+            // Draw unless the update suppressed it.
+            if (_suppressDraw)
+                _suppressDraw = false;
+            else
+            {
+                DoDraw(_gameTime);
+            }
+
+            if (_shouldExit)
+                Platform.Exit();
+        }
+
+        #endregion
+
+        #region Protected Methods
+
+        protected virtual bool BeginDraw() { return true; }
+        protected virtual void EndDraw()
+        {
+            Platform.Present();
+        }
+
+        protected virtual void BeginRun() { }
+        protected virtual void EndRun() { }
+
+        protected virtual void LoadContent() { }
+        protected virtual void UnloadContent() { }
+
+        protected virtual void Initialize()
+        {
+            // TODO: This should be removed once all platforms use the new GraphicsDeviceManager
+#if !(WINDOWS && DIRECTX)
+            applyChanges(graphicsDeviceManager);
+#endif
+
+            // According to the information given on MSDN (see link below), all
+            // GameComponents in Components at the time Initialize() is called
+            // are initialized.
+            // http://msdn.microsoft.com/en-us/library/microsoft.xna.framework.game.initialize.aspx
+            // Initialize all existing components
+            InitializeExistingComponents();
+
+            _graphicsDeviceService = (IGraphicsDeviceService)
+                Services.GetService(typeof(IGraphicsDeviceService));
+
+            if (_graphicsDeviceService != null &&
+                _graphicsDeviceService.GraphicsDevice != null)
+            {
+                LoadContent();
+            }
+        }
+
+        private static readonly Action<IDrawable, GameTime> DrawAction =
+            (drawable, gameTime) => drawable.Draw(gameTime);
+
+        protected virtual void Draw(GameTime gameTime)
+        {
+
+            _drawables.ForEachFilteredItem(DrawAction, gameTime);
+        }
+
+        private static readonly Action<IUpdateable, GameTime> UpdateAction =
+            (updateable, gameTime) => updateable.Update(gameTime);
+
+        protected virtual void Update(GameTime gameTime)
+        {
+            _updateables.ForEachFilteredItem(UpdateAction, gameTime);
+		}
+
+        protected virtual void OnExiting(object sender, EventArgs args)
+        {
+            EventHelpers.Raise(sender, Exiting, args);
+        }
+		
+		protected virtual void OnActivated(object sender, EventArgs args)
+		{
+			AssertNotDisposed();
+            EventHelpers.Raise(sender, Activated, args);
+		}
+		
+		protected virtual void OnDeactivated(object sender, EventArgs args)
+		{
+			AssertNotDisposed();
+            EventHelpers.Raise(sender, Deactivated, args);
+		}
+
+        #endregion Protected Methods
+
+        #region Event Handlers
+
+        private void Components_ComponentAdded(
+            object sender, GameComponentCollectionEventArgs e)
+        {
+            // Since we only subscribe to ComponentAdded after the graphics
+            // devices are set up, it is safe to just blindly call Initialize.
+            e.GameComponent.Initialize();
+            CategorizeComponent(e.GameComponent);
+        }
+
+        private void Components_ComponentRemoved(
+            object sender, GameComponentCollectionEventArgs e)
+        {
+            DecategorizeComponent(e.GameComponent);
+        }
+
+        private void Platform_AsyncRunLoopEnded(object sender, EventArgs e)
+        {
+            AssertNotDisposed();
+
+            var platform = (GamePlatform)sender;
+            platform.AsyncRunLoopEnded -= Platform_AsyncRunLoopEnded;
+            EndRun();
+			DoExiting();
+        }
+
+        #endregion Event Handlers
+
+        #region Internal Methods
+
+        // FIXME: We should work toward eliminating internal methods.  They
+        //        break entirely the possibility that additional platforms could
+        //        be added by third parties without changing MonoGame itself.
+
+#if !(WINDOWS && DIRECTX)
+        internal void applyChanges(GraphicsDeviceManager manager)
+        {
+			Platform.BeginScreenDeviceChange(GraphicsDevice.PresentationParameters.IsFullScreen);
+
+            if (GraphicsDevice.PresentationParameters.IsFullScreen)
+                Platform.EnterFullScreen();
+            else
+                Platform.ExitFullScreen();
+            var viewport = new Viewport(0, 0,
+			                            GraphicsDevice.PresentationParameters.BackBufferWidth,
+			                            GraphicsDevice.PresentationParameters.BackBufferHeight);
+
+            GraphicsDevice.Viewport = viewport;
+			Platform.EndScreenDeviceChange(string.Empty, viewport.Width, viewport.Height);
+        }
+#endif
+
+        internal void DoUpdate(GameTime gameTime)
+        {
+            AssertNotDisposed();
+            if (Platform.BeforeUpdate(gameTime))
+            {
+                FrameworkDispatcher.Update();
+				
+                Update(gameTime);
+
+                //The TouchPanel needs to know the time for when touches arrive
+                TouchPanelState.CurrentTimestamp = gameTime.TotalGameTime;
+            }
+        }
+
+        internal void DoDraw(GameTime gameTime)
+        {
+            AssertNotDisposed();
+            // Draw and EndDraw should not be called if BeginDraw returns false.
+            // http://stackoverflow.com/questions/4054936/manual-control-over-when-to-redraw-the-screen/4057180#4057180
+            // http://stackoverflow.com/questions/4235439/xna-3-1-to-4-0-requires-constant-redraw-or-will-display-a-purple-screen
+            if (Platform.BeforeDraw(gameTime) && BeginDraw())
+            {
+                Draw(gameTime);
+                EndDraw();
+            }
+        }
+
+        internal void DoInitialize()
+        {
+            AssertNotDisposed();
+            if (GraphicsDevice == null && graphicsDeviceManager != null)
+                _graphicsDeviceManager.CreateDevice();
+
+            Platform.BeforeInitialize();
+            Initialize();
+
+            // We need to do this after virtual Initialize(...) is called.
+            // 1. Categorize components into IUpdateable and IDrawable lists.
+            // 2. Subscribe to Added/Removed events to keep the categorized
+            //    lists synced and to Initialize future components as they are
+            //    added.            
+            CategorizeComponents();
+            _components.ComponentAdded += Components_ComponentAdded;
+            _components.ComponentRemoved += Components_ComponentRemoved;
+        }
+
+		internal void DoExiting()
+		{
+			OnExiting(this, EventArgs.Empty);
+			UnloadContent();
+		}
+
+        #endregion Internal Methods
+
+        internal GraphicsDeviceManager graphicsDeviceManager
+        {
+            get
+            {
+                if (_graphicsDeviceManager == null)
+                {
+                    _graphicsDeviceManager = (IGraphicsDeviceManager)
+                        Services.GetService(typeof(IGraphicsDeviceManager));
+                }
+                return (GraphicsDeviceManager)_graphicsDeviceManager;
+            }
+            set
+            {
+                if (_graphicsDeviceManager != null)
+                    throw new InvalidOperationException("GraphicsDeviceManager already registered for this Game object");
+                _graphicsDeviceManager = value;
+            }
+        }
+
+        // NOTE: InitializeExistingComponents really should only be called once.
+        //       Game.Initialize is the only method in a position to guarantee
+        //       that no component will get a duplicate Initialize call.
+        //       Further calls to Initialize occur immediately in response to
+        //       Components.ComponentAdded.
+        private void InitializeExistingComponents()
+        {
+            for(int i = 0; i < Components.Count; ++i)
+                Components[i].Initialize();
+        }
+
+        private void CategorizeComponents()
+        {
+            DecategorizeComponents();
+            for (int i = 0; i < Components.Count; ++i)
+                CategorizeComponent(Components[i]);
+        }
+
+        // FIXME: I am open to a better name for this method.  It does the
+        //        opposite of CategorizeComponents.
+        private void DecategorizeComponents()
+        {
+            _updateables.Clear();
+            _drawables.Clear();
+        }
+
+        private void CategorizeComponent(IGameComponent component)
+        {
+            if (component is IUpdateable)
+                _updateables.Add((IUpdateable)component);
+            if (component is IDrawable)
+                _drawables.Add((IDrawable)component);
+        }
+
+        // FIXME: I am open to a better name for this method.  It does the
+        //        opposite of CategorizeComponent.
+        private void DecategorizeComponent(IGameComponent component)
+        {
+            if (component is IUpdateable)
+                _updateables.Remove((IUpdateable)component);
+            if (component is IDrawable)
+                _drawables.Remove((IDrawable)component);
+        }
+
+        /// <summary>
+        /// The SortingFilteringCollection class provides efficient, reusable
+        /// sorting and filtering based on a configurable sort comparer, filter
+        /// predicate, and associate change events.
+        /// </summary>
+        class SortingFilteringCollection<T> : ICollection<T>
+        {
+            private readonly List<T> _items;
+            private readonly List<AddJournalEntry<T>> _addJournal;
+            private readonly Comparison<AddJournalEntry<T>> _addJournalSortComparison;
+            private readonly List<int> _removeJournal;
+            private readonly List<T> _cachedFilteredItems;
+            private bool _shouldRebuildCache;
+
+            private readonly Predicate<T> _filter;
+            private readonly Comparison<T> _sort;
+            private readonly Action<T, EventHandler<EventArgs>> _filterChangedSubscriber;
+            private readonly Action<T, EventHandler<EventArgs>> _filterChangedUnsubscriber;
+            private readonly Action<T, EventHandler<EventArgs>> _sortChangedSubscriber;
+            private readonly Action<T, EventHandler<EventArgs>> _sortChangedUnsubscriber;
+
+            public SortingFilteringCollection(
+                Predicate<T> filter,
+                Action<T, EventHandler<EventArgs>> filterChangedSubscriber,
+                Action<T, EventHandler<EventArgs>> filterChangedUnsubscriber,
+                Comparison<T> sort,
+                Action<T, EventHandler<EventArgs>> sortChangedSubscriber,
+                Action<T, EventHandler<EventArgs>> sortChangedUnsubscriber)
+            {
+                _items = new List<T>();
+                _addJournal = new List<AddJournalEntry<T>>();
+                _removeJournal = new List<int>();
+                _cachedFilteredItems = new List<T>();
+                _shouldRebuildCache = true;
+
+                _filter = filter;
+                _filterChangedSubscriber = filterChangedSubscriber;
+                _filterChangedUnsubscriber = filterChangedUnsubscriber;
+                _sort = sort;
+                _sortChangedSubscriber = sortChangedSubscriber;
+                _sortChangedUnsubscriber = sortChangedUnsubscriber;
+
+                _addJournalSortComparison = CompareAddJournalEntry;
+            }
+
+            private int CompareAddJournalEntry(AddJournalEntry<T> x, AddJournalEntry<T> y)
+            {
+                int result = _sort(x.Item, y.Item);
+                if (result != 0)
+                    return result;
+                return x.Order - y.Order;
+            }
+
+            public void ForEachFilteredItem<TUserData>(Action<T, TUserData> action, TUserData userData)
+            {
+                if (_shouldRebuildCache)
+                {
+                    ProcessRemoveJournal();
+                    ProcessAddJournal();
+
+                    // Rebuild the cache
+                    _cachedFilteredItems.Clear();
+                    for (int i = 0; i < _items.Count; ++i)
+                        if (_filter(_items[i]))
+                            _cachedFilteredItems.Add(_items[i]);
+
+                    _shouldRebuildCache = false;
+                }
+
+                for (int i = 0; i < _cachedFilteredItems.Count; ++i)
+                    action(_cachedFilteredItems[i], userData);
+
+                // If the cache was invalidated as a result of processing items,
+                // now is a good time to clear it and give the GC (more of) a
+                // chance to do its thing.
+                if (_shouldRebuildCache)
+                    _cachedFilteredItems.Clear();
+            }
+
+            public void Add(T item)
+            {
+                // NOTE: We subscribe to item events after items in _addJournal
+                //       have been merged.
+                _addJournal.Add(new AddJournalEntry<T>(_addJournal.Count, item));
+                InvalidateCache();
+            }
+
+            public bool Remove(T item)
+            {
+                if (_addJournal.Remove(AddJournalEntry<T>.CreateKey(item)))
+                    return true;
+
+                var index = _items.IndexOf(item);
+                if (index >= 0)
+                {
+                    UnsubscribeFromItemEvents(item);
+                    _removeJournal.Add(index);
+                    InvalidateCache();
+                    return true;
+                }
+                return false;
+            }
+
+            public void Clear()
+            {
+                for (int i = 0; i < _items.Count; ++i)
+                {
+                    _filterChangedUnsubscriber(_items[i], Item_FilterPropertyChanged);
+                    _sortChangedUnsubscriber(_items[i], Item_SortPropertyChanged);
+                }
+
+                _addJournal.Clear();
+                _removeJournal.Clear();
+                _items.Clear();
+
+                InvalidateCache();
+            }
+
+            public bool Contains(T item)
+            {
+                return _items.Contains(item);
+            }
+
+            public void CopyTo(T[] array, int arrayIndex)
+            {
+                _items.CopyTo(array, arrayIndex);
+            }
+
+            public int Count
+            {
+                get { return _items.Count; }
+            }
+
+            public bool IsReadOnly
+            {
+                get { return false; }
+            }
+
+            public IEnumerator<T> GetEnumerator()
+            {
+                return _items.GetEnumerator();
+            }
+
+            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+            {
+                return ((System.Collections.IEnumerable)_items).GetEnumerator();
+            }
+
+            private static readonly Comparison<int> RemoveJournalSortComparison =
+                (x, y) => Comparer<int>.Default.Compare(y, x); // Sort high to low
+            private void ProcessRemoveJournal()
+            {
+                if (_removeJournal.Count == 0)
+                    return;
+
+                // Remove items in reverse.  (Technically there exist faster
+                // ways to bulk-remove from a variable-length array, but List<T>
+                // does not provide such a method.)
+                _removeJournal.Sort(RemoveJournalSortComparison);
+                for (int i = 0; i < _removeJournal.Count; ++i)
+                    _items.RemoveAt(_removeJournal[i]);
+                _removeJournal.Clear();
+            }
+
+            private void ProcessAddJournal()
+            {
+                if (_addJournal.Count == 0)
+                    return;
+
+                // Prepare the _addJournal to be merge-sorted with _items.
+                // _items is already sorted (because it is always sorted).
+                _addJournal.Sort(_addJournalSortComparison);
+
+                int iAddJournal = 0;
+                int iItems = 0;
+
+                while (iItems < _items.Count && iAddJournal < _addJournal.Count)
+                {
+                    var addJournalItem = _addJournal[iAddJournal].Item;
+                    // If addJournalItem is less than (belongs before)
+                    // _items[iItems], insert it.
+                    if (_sort(addJournalItem, _items[iItems]) < 0)
+                    {
+                        SubscribeToItemEvents(addJournalItem);
+                        _items.Insert(iItems, addJournalItem);
+                        ++iAddJournal;
+                    }
+                    // Always increment iItems, either because we inserted and
+                    // need to move past the insertion, or because we didn't
+                    // insert and need to consider the next element.
+                    ++iItems;
+                }
+
+                // If _addJournal had any "tail" items, append them all now.
+                for (; iAddJournal < _addJournal.Count; ++iAddJournal)
+                {
+                    var addJournalItem = _addJournal[iAddJournal].Item;
+                    SubscribeToItemEvents(addJournalItem);
+                    _items.Add(addJournalItem);
+                }
+
+                _addJournal.Clear();
+            }
+
+            private void SubscribeToItemEvents(T item)
+            {
+                _filterChangedSubscriber(item, Item_FilterPropertyChanged);
+                _sortChangedSubscriber(item, Item_SortPropertyChanged);
+            }
+
+            private void UnsubscribeFromItemEvents(T item)
+            {
+                _filterChangedUnsubscriber(item, Item_FilterPropertyChanged);
+                _sortChangedUnsubscriber(item, Item_SortPropertyChanged);
+            }
+
+            private void InvalidateCache()
+            {
+                _shouldRebuildCache = true;
+            }
+
+            private void Item_FilterPropertyChanged(object sender, EventArgs e)
+            {
+                InvalidateCache();
+            }
+
+            private void Item_SortPropertyChanged(object sender, EventArgs e)
+            {
+                var item = (T)sender;
+                var index = _items.IndexOf(item);
+
+                _addJournal.Add(new AddJournalEntry<T>(_addJournal.Count, item));
+                _removeJournal.Add(index);
+
+                // Until the item is back in place, we don't care about its
+                // events.  We will re-subscribe when _addJournal is processed.
+                UnsubscribeFromItemEvents(item);
+                InvalidateCache();
+            }
+        }
+
+        private struct AddJournalEntry<T>
+        {
+            public readonly int Order;
+            public readonly T Item;
+
+            public AddJournalEntry(int order, T item)
+            {
+                Order = order;
+                Item = item;
+            }
+
+            public static AddJournalEntry<T> CreateKey(T item)
+            {
+                return new AddJournalEntry<T>(-1, item);
+            }
+
+            public override int GetHashCode()
+            {
+                return Item.GetHashCode();
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (!(obj is AddJournalEntry<T>))
+                    return false;
+
+                return object.Equals(Item, ((AddJournalEntry<T>)obj).Item);
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/GameComponent.cs b/MonoGame.Framework/GameComponent.cs
new file mode 100644
index 00000000000..43ab17c951c
--- /dev/null
+++ b/MonoGame.Framework/GameComponent.cs
@@ -0,0 +1,92 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework
+{   
+    public class GameComponent : IGameComponent, IUpdateable, IComparable<GameComponent>, IDisposable
+    {
+        bool _enabled = true;
+        int _updateOrder;
+
+        public Game Game { get; private set; }
+
+        public bool Enabled
+        {
+            get { return _enabled; }
+            set
+            {
+                if (_enabled != value)
+                {
+                    _enabled = value;
+                    OnEnabledChanged(this, EventArgs.Empty);
+                }
+            }
+        }
+
+        public int UpdateOrder
+        {
+            get { return _updateOrder; }
+            set
+            {
+                if (_updateOrder != value)
+                {
+                    _updateOrder = value;
+                    OnUpdateOrderChanged(this, EventArgs.Empty);
+                }
+            }
+        }
+
+        public event EventHandler<EventArgs> EnabledChanged;
+        public event EventHandler<EventArgs> UpdateOrderChanged;
+
+        public GameComponent(Game game)
+        {
+            this.Game = game;
+        }
+
+        ~GameComponent()
+        {
+            Dispose(false);
+        }
+
+        public virtual void Initialize() { }
+
+        public virtual void Update(GameTime gameTime) { }
+
+        protected virtual void OnUpdateOrderChanged(object sender, EventArgs args)
+        {
+            EventHelpers.Raise(sender, UpdateOrderChanged, args);
+        }
+
+        protected virtual void OnEnabledChanged(object sender, EventArgs args)
+        {
+            EventHelpers.Raise(sender, EnabledChanged, args);
+        }
+
+        /// <summary>
+        /// Shuts down the component.
+        /// </summary>
+        protected virtual void Dispose(bool disposing) { }
+        
+        /// <summary>
+        /// Shuts down the component.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        #region IComparable<GameComponent> Members
+        // TODO: Should be removed, as it is not part of XNA 4.0
+        public int CompareTo(GameComponent other)
+        {
+            return other.UpdateOrder - this.UpdateOrder;
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/GameComponentCollection.cs b/MonoGame.Framework/GameComponentCollection.cs
new file mode 100644
index 00000000000..41698f9b574
--- /dev/null
+++ b/MonoGame.Framework/GameComponentCollection.cs
@@ -0,0 +1,76 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.ObjectModel;
+
+namespace Microsoft.Xna.Framework
+{
+    public sealed class GameComponentCollection : Collection<IGameComponent>
+    {
+        /// <summary>
+        /// Event that is triggered when a <see cref="GameComponent"/> is added
+        /// to this <see cref="GameComponentCollection"/>.
+        /// </summary>
+        public event EventHandler<GameComponentCollectionEventArgs> ComponentAdded;
+
+        /// <summary>
+        /// Event that is triggered when a <see cref="GameComponent"/> is removed
+        /// from this <see cref="GameComponentCollection"/>.
+        /// </summary>
+        public event EventHandler<GameComponentCollectionEventArgs> ComponentRemoved;
+
+        /// <summary>
+        /// Removes every <see cref="GameComponent"/> from this <see cref="GameComponentCollection"/>.
+        /// Triggers <see cref="OnComponentRemoved"/> once for each <see cref="GameComponent"/> removed.
+        /// </summary>
+        protected override void ClearItems()
+        {
+            for (int i = 0; i < base.Count; i++)
+            {
+                this.OnComponentRemoved(new GameComponentCollectionEventArgs(base[i]));
+            }
+            base.ClearItems();
+        }
+
+        protected override void InsertItem(int index, IGameComponent item)
+        {
+            if (base.IndexOf(item) != -1)
+            {
+                throw new ArgumentException("Cannot Add Same Component Multiple Times");
+            }
+            base.InsertItem(index, item);
+            if (item != null)
+            {
+                this.OnComponentAdded(new GameComponentCollectionEventArgs(item));
+            }
+        }
+
+        private void OnComponentAdded(GameComponentCollectionEventArgs eventArgs)
+        {
+            EventHelpers.Raise(this, ComponentAdded, eventArgs);
+        }
+
+        private void OnComponentRemoved(GameComponentCollectionEventArgs eventArgs)
+        {
+            EventHelpers.Raise(this, ComponentRemoved, eventArgs);
+        }
+
+        protected override void RemoveItem(int index)
+        {
+            IGameComponent gameComponent = base[index];
+            base.RemoveItem(index);
+            if (gameComponent != null)
+            {
+                this.OnComponentRemoved(new GameComponentCollectionEventArgs(gameComponent));
+            }
+        }
+
+        protected override void SetItem(int index, IGameComponent item)
+        {
+            throw new NotSupportedException();
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/GameComponentCollectionEventArgs.cs b/MonoGame.Framework/GameComponentCollectionEventArgs.cs
new file mode 100644
index 00000000000..3d0f2482db3
--- /dev/null
+++ b/MonoGame.Framework/GameComponentCollectionEventArgs.cs
@@ -0,0 +1,27 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework
+{
+    public class GameComponentCollectionEventArgs : EventArgs
+    {
+        private IGameComponent _gameComponent;
+
+        public GameComponentCollectionEventArgs(IGameComponent gameComponent)
+        {
+            _gameComponent = gameComponent;
+        }
+
+        public IGameComponent GameComponent
+        {
+            get
+            {
+                return _gameComponent;
+            }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/GamePlatform.Desktop.cs b/MonoGame.Framework/GamePlatform.Desktop.cs
new file mode 100644
index 00000000000..25321a3d353
--- /dev/null
+++ b/MonoGame.Framework/GamePlatform.Desktop.cs
@@ -0,0 +1,26 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+#if WINDOWS_UAP
+using Windows.UI.ViewManagement;
+#endif
+
+namespace Microsoft.Xna.Framework
+{
+    partial class GamePlatform
+    {
+        internal static GamePlatform PlatformCreate(Game game)
+        {
+#if DESKTOPGL || ANGLE
+            return new SdlGamePlatform(game);
+#elif WINDOWS && DIRECTX
+            return new MonoGame.Framework.WinFormsGamePlatform(game);
+#elif WINDOWS_UAP
+            return new UAPGamePlatform(game);
+#endif
+        }
+   }
+}
diff --git a/MonoGame.Framework/GamePlatform.Mobile.cs b/MonoGame.Framework/GamePlatform.Mobile.cs
new file mode 100644
index 00000000000..64de849f8ea
--- /dev/null
+++ b/MonoGame.Framework/GamePlatform.Mobile.cs
@@ -0,0 +1,24 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework
+{
+    partial class GamePlatform
+    {
+        internal static GamePlatform PlatformCreate(Game game)
+        {
+#if IOS
+            return new iOSGamePlatform(game);
+#elif ANDROID
+            return new AndroidGamePlatform(game);
+#elif WINDOWS_PHONE81
+            return new MetroGamePlatform(game);
+#elif WEB
+            return new WebGamePlatform(game);
+#endif
+        }
+    }
+}
diff --git a/MonoGame.Framework/GamePlatform.cs b/MonoGame.Framework/GamePlatform.cs
new file mode 100644
index 00000000000..6b73db350d8
--- /dev/null
+++ b/MonoGame.Framework/GamePlatform.cs
@@ -0,0 +1,296 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using Microsoft.Xna.Framework.Input.Touch;
+
+
+namespace Microsoft.Xna.Framework
+{
+    abstract partial class GamePlatform : IDisposable
+    {
+        #region Fields
+
+        protected TimeSpan _inactiveSleepTime = TimeSpan.FromMilliseconds(20.0);
+        protected bool _needsToResetElapsedTime = false;
+        bool disposed;
+        protected bool InFullScreenMode = false;
+        protected bool IsDisposed { get { return disposed; } }
+
+        #endregion
+
+        #region Construction/Destruction
+
+		protected GamePlatform(Game game)
+        {
+            if (game == null)
+                throw new ArgumentNullException("game");
+            Game = game;
+        }
+
+        ~GamePlatform()
+        {
+            Dispose(false);
+        }
+
+        #endregion Construction/Destruction
+
+        #region Public Properties
+
+        /// <summary>
+        /// When implemented in a derived class, reports the default
+        /// GameRunBehavior for this platform.
+        /// </summary>
+        public abstract GameRunBehavior DefaultRunBehavior { get; }
+
+        /// <summary>
+        /// Gets the Game instance that owns this GamePlatform instance.
+        /// </summary>
+        public Game Game
+        {
+            get; private set;
+        }
+
+        private bool _isActive;
+        public bool IsActive
+        {
+            get { return _isActive; }
+            internal set
+            {
+                if (_isActive != value)
+                {
+                    _isActive = value;
+                    EventHelpers.Raise(this, _isActive ? Activated : Deactivated, EventArgs.Empty);
+                }
+            }
+        }
+
+        private bool _isMouseVisible;
+        public bool IsMouseVisible
+        {
+            get { return _isMouseVisible; }
+            set
+            {
+                if (_isMouseVisible != value)
+                {
+                    _isMouseVisible = value;
+                    OnIsMouseVisibleChanged();
+                }
+            }
+        }
+
+        private GameWindow _window;
+        public GameWindow Window
+        {
+            get { return _window; }
+
+
+            protected set
+            {
+                if (_window == null)
+                {
+                    Mouse.PrimaryWindow = value;
+                    TouchPanel.PrimaryWindow = value;
+                }
+
+                _window = value;
+            }
+        }
+
+        #endregion
+
+        #region Events
+
+        public event EventHandler<EventArgs> AsyncRunLoopEnded;
+        public event EventHandler<EventArgs> Activated;
+        public event EventHandler<EventArgs> Deactivated;
+
+        /// <summary>
+        /// Raises the AsyncRunLoopEnded event.  This method must be called by
+        /// derived classes when the asynchronous run loop they start has
+        /// stopped running.
+        /// </summary>
+        protected void RaiseAsyncRunLoopEnded()
+        {
+            EventHelpers.Raise(this, AsyncRunLoopEnded, EventArgs.Empty);
+        }
+
+        #endregion Events
+
+        #region Methods
+
+        /// <summary>
+        /// Gives derived classes an opportunity to do work before any
+        /// components are initialized.  Note that the base implementation sets
+        /// IsActive to true, so derived classes should either call the base
+        /// implementation or set IsActive to true by their own means.
+        /// </summary>
+        public virtual void BeforeInitialize()
+        {
+            IsActive = true;
+        }
+
+        /// <summary>
+        /// Gives derived classes an opportunity to do work just before the
+        /// run loop is begun.  Implementations may also return false to prevent
+        /// the run loop from starting.
+        /// </summary>
+        /// <returns></returns>
+        public virtual bool BeforeRun()
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// When implemented in a derived, ends the active run loop.
+        /// </summary>
+        public abstract void Exit();
+
+        /// <summary>
+        /// When implemented in a derived, starts the run loop and blocks
+        /// until it has ended.
+        /// </summary>
+        public abstract void RunLoop();
+
+        /// <summary>
+        /// When implemented in a derived, starts the run loop and returns
+        /// immediately.
+        /// </summary>
+        public abstract void StartRunLoop();
+
+        /// <summary>
+        /// Gives derived classes an opportunity to do work just before Update
+        /// is called for all IUpdatable components.  Returning false from this
+        /// method will result in this round of Update calls being skipped.
+        /// </summary>
+        /// <param name="gameTime"></param>
+        /// <returns></returns>
+        public abstract bool BeforeUpdate(GameTime gameTime);
+
+        /// <summary>
+        /// Gives derived classes an opportunity to do work just before Draw
+        /// is called for all IDrawable components.  Returning false from this
+        /// method will result in this round of Draw calls being skipped.
+        /// </summary>
+        /// <param name="gameTime"></param>
+        /// <returns></returns>
+        public abstract bool BeforeDraw(GameTime gameTime);
+
+        /// <summary>
+        /// When implemented in a derived class, causes the game to enter
+        /// full-screen mode.
+        /// </summary>
+        public abstract void EnterFullScreen();
+
+        /// <summary>
+        /// When implemented in a derived class, causes the game to exit
+        /// full-screen mode.
+        /// </summary>
+        public abstract void ExitFullScreen();
+
+        /// <summary>
+        /// Gives derived classes an opportunity to modify
+        /// Game.TargetElapsedTime before it is set.
+        /// </summary>
+        /// <param name="value">The proposed new value of TargetElapsedTime.</param>
+        /// <returns>The new value of TargetElapsedTime that will be set.</returns>
+        public virtual TimeSpan TargetElapsedTimeChanging(TimeSpan value)
+        {
+            return value;
+        }
+        /// <summary>
+        /// Starts a device transition (windowed to full screen or vice versa).
+        /// </summary>
+        /// <param name='willBeFullScreen'>
+        /// Specifies whether the device will be in full-screen mode upon completion of the change.
+        /// </param>
+        public abstract void BeginScreenDeviceChange (
+                 bool willBeFullScreen
+        );
+
+        /// <summary>
+        /// Completes a device transition.
+        /// </summary>
+        /// <param name='screenDeviceName'>
+        /// Screen device name.
+        /// </param>
+        /// <param name='clientWidth'>
+        /// The new width of the game's client window.
+        /// </param>
+        /// <param name='clientHeight'>
+        /// The new height of the game's client window.
+        /// </param>
+        public abstract void EndScreenDeviceChange (
+                 string screenDeviceName,
+                 int clientWidth,
+                 int clientHeight
+        );
+
+        /// <summary>
+        /// Gives derived classes an opportunity to take action after
+        /// Game.TargetElapsedTime has been set.
+        /// </summary>
+        public virtual void TargetElapsedTimeChanged() {}
+
+        /// <summary>
+        /// MSDN: Use this method if your game is recovering from a slow-running state, and ElapsedGameTime is too large to be useful.
+        /// Frame timing is generally handled by the Game class, but some platforms still handle it elsewhere. Once all platforms
+        /// rely on the Game class's functionality, this method and any overrides should be removed.
+        /// </summary>
+        public virtual void ResetElapsedTime() {}
+
+        public virtual void Present() { }
+
+        protected virtual void OnIsMouseVisibleChanged() {}
+
+        /// <summary>
+        /// Called by the GraphicsDeviceManager to notify the platform
+        /// that the presentation parameters have changed.
+        /// </summary>
+        /// <param name="pp">The new presentation parameters.</param>
+        internal virtual void OnPresentationChanged(PresentationParameters pp)
+        {
+        }
+
+        #endregion Methods
+
+        #region IDisposable implementation
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing,
+        /// releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposed)
+            {
+                Mouse.PrimaryWindow = null;
+                TouchPanel.PrimaryWindow = null;
+
+                disposed = true;
+            }
+        }
+		
+		/// <summary>
+		/// Log the specified Message.
+		/// </summary>
+		/// <param name='Message'>
+		/// 
+		/// </param>
+		[System.Diagnostics.Conditional("DEBUG")]
+		public virtual void Log(string Message) {}		
+			
+
+        #endregion
+    }
+}
+
diff --git a/MonoGame.Framework/GameRunBehavior.cs b/MonoGame.Framework/GameRunBehavior.cs
new file mode 100644
index 00000000000..9be830ac79a
--- /dev/null
+++ b/MonoGame.Framework/GameRunBehavior.cs
@@ -0,0 +1,21 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Defines how <see cref="Game"/> should be runned.
+    /// </summary>
+    public enum GameRunBehavior
+    {
+        /// <summary>
+        /// The game loop will be runned asynchronous.
+        /// </summary>
+        Asynchronous,
+        /// <summary>
+        /// The game loop will be runned synchronous.
+        /// </summary>
+        Synchronous
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/GameServiceContainer.cs b/MonoGame.Framework/GameServiceContainer.cs
new file mode 100644
index 00000000000..30c73415b30
--- /dev/null
+++ b/MonoGame.Framework/GameServiceContainer.cs
@@ -0,0 +1,67 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework
+{
+    public class GameServiceContainer : IServiceProvider
+    {
+        Dictionary<Type, object> services;
+
+        public GameServiceContainer()
+        {
+            services = new Dictionary<Type, object>();
+        }
+
+        public void AddService(Type type, object provider)
+        {
+            if (type == null)
+                throw new ArgumentNullException("type");
+            if (provider == null)
+                throw new ArgumentNullException("provider");
+            if (!ReflectionHelpers.IsAssignableFrom(type, provider))
+                throw new ArgumentException("The provider does not match the specified service type!");
+
+            services.Add(type, provider);
+        }
+
+        public object GetService(Type type)
+        {
+            if (type == null)
+                throw new ArgumentNullException("type");
+						
+            object service;
+            if (services.TryGetValue(type, out service))
+                return service;
+
+            return null;
+        }
+
+        public void RemoveService(Type type)
+        {
+            if (type == null)
+                throw new ArgumentNullException("type");
+
+            services.Remove(type);
+        }
+        
+        public void AddService<T>(T provider)
+        {
+            AddService(typeof(T), provider);
+        }
+
+ 	public T GetService<T>() where T : class
+        {
+            var service = GetService(typeof(T));
+
+            if (service == null)
+                return null;
+
+            return (T)service;
+        }
+    }
+}
diff --git a/MonoGame.Framework/GameTime.cs b/MonoGame.Framework/GameTime.cs
new file mode 100644
index 00000000000..4dd4b05dbd4
--- /dev/null
+++ b/MonoGame.Framework/GameTime.cs
@@ -0,0 +1,39 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework
+{
+    public class GameTime
+    {
+        public TimeSpan TotalGameTime { get; set; }
+
+        public TimeSpan ElapsedGameTime { get; set; }
+
+        public bool IsRunningSlowly { get; set; }
+
+        public GameTime()
+        {
+            TotalGameTime = TimeSpan.Zero;
+            ElapsedGameTime = TimeSpan.Zero;
+            IsRunningSlowly = false;
+        }
+
+        public GameTime(TimeSpan totalGameTime, TimeSpan elapsedGameTime)
+        {
+            TotalGameTime = totalGameTime;
+            ElapsedGameTime = elapsedGameTime;
+            IsRunningSlowly = false;
+        }
+
+		public GameTime (TimeSpan totalRealTime, TimeSpan elapsedRealTime, bool isRunningSlowly)
+		{
+            TotalGameTime = totalRealTime;
+            ElapsedGameTime = elapsedRealTime;
+		    IsRunningSlowly = isRunningSlowly;
+		}
+    }
+}
+
diff --git a/MonoGame.Framework/GameWindow.cs b/MonoGame.Framework/GameWindow.cs
new file mode 100644
index 00000000000..3e6f93d0446
--- /dev/null
+++ b/MonoGame.Framework/GameWindow.cs
@@ -0,0 +1,168 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using Microsoft.Xna.Framework.Input;
+using Microsoft.Xna.Framework.Input.Touch;
+using System;
+using System.ComponentModel;
+
+namespace Microsoft.Xna.Framework {
+	public abstract class GameWindow {
+		#region Properties
+
+		[DefaultValue(false)]
+		public abstract bool AllowUserResizing { get; set; }
+
+		public abstract Rectangle ClientBounds { get; }
+
+	    internal bool _allowAltF4 = true;
+
+        /// <summary>
+        /// Gets or sets a bool that enables usage of Alt+F4 for window closing on desktop platforms. Value is true by default.
+        /// </summary>
+        public virtual bool AllowAltF4 { get { return _allowAltF4; } set { _allowAltF4 = value; } }
+
+#if (WINDOWS && !WINDOWS_UAP) || DESKTOPGL
+        /// <summary>
+        /// The location of this window on the desktop, eg: global coordinate space
+        /// which stretches across all screens.
+        /// </summary>
+        public abstract Point Position { get; set; }
+#endif
+
+		public abstract DisplayOrientation CurrentOrientation { get; }
+
+		public abstract IntPtr Handle { get; }
+
+		public abstract string ScreenDeviceName { get; }
+
+		private string _title;
+        /// <summary>
+        /// Gets or sets the title of the game window.
+        /// </summary>
+        /// <remarks>
+        /// For Windows 8 and Windows 10 UWP this has no effect. For these platforms the title should be
+        /// set by using the DisplayName property found in the app manifest file.
+        /// </remarks>
+        public string Title {
+			get { return _title; }
+			set {
+				if (_title != value) {
+					SetTitle(value);
+					_title = value;
+				}
+			}
+		}
+
+        /// <summary>
+        /// Determines whether the border of the window is visible. Currently only supported on the WinDX and WinGL/Linux platforms.
+        /// </summary>
+        /// <exception cref="System.NotImplementedException">
+        /// Thrown when trying to use this property on a platform other than the WinDX and WinGL/Linux platforms.
+        /// </exception>
+        public virtual bool IsBorderless
+        {
+            get
+            {
+                return false;
+            }
+            set
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        internal MouseState MouseState;
+	    internal TouchPanelState TouchPanelState;
+
+        protected GameWindow()
+        {
+            TouchPanelState = new TouchPanelState(this);
+        }
+
+		#endregion Properties
+
+		#region Events
+
+		public event EventHandler<EventArgs> ClientSizeChanged;
+		public event EventHandler<EventArgs> OrientationChanged;
+		public event EventHandler<EventArgs> ScreenDeviceNameChanged;
+
+#if WINDOWS || WINDOWS_UAP || DESKTOPGL|| ANGLE
+
+        /// <summary>
+		/// Use this event to retrieve text for objects like textbox's.
+		/// This event is not raised by noncharacter keys.
+		/// This event also supports key repeat.
+		/// For more information this event is based off:
+		/// http://msdn.microsoft.com/en-AU/library/system.windows.forms.control.keypress.aspx
+		/// </summary>
+		/// <remarks>
+		/// This event is only supported on the Windows DirectX, Windows OpenGL and Linux platforms.
+		/// </remarks>
+		public event EventHandler<TextInputEventArgs> TextInput;
+
+        internal bool IsTextInputHandled { get { return TextInput != null; } }
+#endif
+
+		#endregion Events
+
+		public abstract void BeginScreenDeviceChange (bool willBeFullScreen);
+
+		public abstract void EndScreenDeviceChange (
+			string screenDeviceName, int clientWidth, int clientHeight);
+
+		public void EndScreenDeviceChange (string screenDeviceName)
+		{
+			EndScreenDeviceChange(screenDeviceName, ClientBounds.Width, ClientBounds.Height);
+		}
+
+		protected void OnActivated ()
+		{
+		}
+
+		internal void OnClientSizeChanged ()
+		{
+            EventHelpers.Raise(this, ClientSizeChanged, EventArgs.Empty);
+		}
+
+		protected void OnDeactivated ()
+		{
+		}
+         
+		protected void OnOrientationChanged ()
+		{
+            EventHelpers.Raise(this, OrientationChanged, EventArgs.Empty);
+		}
+
+		protected void OnPaint ()
+		{
+		}
+
+		protected void OnScreenDeviceNameChanged ()
+		{
+            EventHelpers.Raise(this, ScreenDeviceNameChanged, EventArgs.Empty);
+		}
+
+#if WINDOWS || WINDOWS_UAP || DESKTOPGL || ANGLE
+		protected void OnTextInput(object sender, TextInputEventArgs e)
+		{
+            EventHelpers.Raise(this, TextInput, e);
+		}
+#endif
+
+		protected internal abstract void SetSupportedOrientations (DisplayOrientation orientations);
+		protected abstract void SetTitle (string title);
+
+#if DIRECTX && WINDOWS
+        public static GameWindow Create(Game game, int width, int height)
+        {
+            var window = new MonoGame.Framework.WinFormsGameWindow((MonoGame.Framework.WinFormsGamePlatform)game.Platform);
+            window.Initialize(width, height);
+
+            return window;
+        }
+#endif
+    }
+}
diff --git a/MonoGame.Framework/GamerServices/Achievement.cs b/MonoGame.Framework/GamerServices/Achievement.cs
new file mode 100644
index 00000000000..3005533e8a9
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/Achievement.cs
@@ -0,0 +1,89 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+// 
+using System;
+using System.IO;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    [DataContract]
+    public class Achievement
+	{
+		public Achievement ()
+		{
+		}
+
+        [DataMember]
+        public string Description { get; internal set; }
+
+        [DataMember]
+        public bool DisplayBeforeEarned { get; internal set; }
+
+        [DataMember]
+        public DateTime EarnedDateTime { get; internal set; }
+
+        [DataMember]
+        public bool EarnedOnline { get; internal set; }
+
+        [DataMember]
+        public int GamerScore { get; internal set; }
+
+        [DataMember]
+        public string HowToEarn { get; internal set; }
+
+        [DataMember]
+        public bool IsEarned { get; internal set; }
+
+        [DataMember]
+        public string Key { get; internal set; }
+
+        [DataMember]
+        public string Name { get; internal set; }
+
+        /*
+		public Stream GetPicture ()
+		{
+			throw new NotImplementedException();
+		}
+        */
+	}
+}
+
diff --git a/MonoGame.Framework/GamerServices/AchievementCollection.cs b/MonoGame.Framework/GamerServices/AchievementCollection.cs
new file mode 100644
index 00000000000..1bac25412a8
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/AchievementCollection.cs
@@ -0,0 +1,182 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+// 
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	public class AchievementCollection : IList<Achievement>, ICollection<Achievement>, IEnumerable<Achievement>, IEnumerable, IDisposable
+	{
+		private List<Achievement> innerlist;
+		
+		public AchievementCollection ()
+		{
+			innerlist = new List<Achievement>();
+		}
+		
+        ~AchievementCollection()
+        {
+            Dispose(false);
+        }
+
+		#region Properties
+		public int Count
+        {
+            get { return innerlist.Count; }
+        }
+		
+		public Achievement this[int index]
+        {
+            get { return innerlist[index]; }
+            set
+            {
+                if (value == null)
+                    throw new ArgumentNullException();
+
+                if (index >= innerlist.Count)
+                    throw new IndexOutOfRangeException();
+
+                /*if (innerlist[index].Position == value.Position)
+                    innerlist[index] = value;
+                else
+                {
+                    innerlist.RemoveAt(index);
+                    innerlist.Add(value);
+                }*/
+            }
+        }
+
+		private bool isReadOnly = false;
+		public bool IsReadOnly 
+		{
+            get
+			{
+				return isReadOnly;
+			}
+        }
+		
+        #endregion Properties
+		
+		#region Public Methods
+		public void Add(Achievement item)
+        {
+            if (item == null)
+                throw new ArgumentNullException();
+
+            if (innerlist.Count == 0)
+            {
+                innerlist.Add(item);
+                return;
+            }
+
+            for (int i = 0; i < innerlist.Count; i++)
+            {
+                /*if (item.Position < innerlist[i].Position)
+                {
+                    this.innerlist.Insert(i, item);
+                    return;
+                }*/
+            }
+
+            this.innerlist.Add(item);
+        }
+
+        public void Clear()
+        {
+            innerlist.Clear();
+        }
+		
+		public bool Contains(Achievement item)
+        {
+            return innerlist.Contains(item);
+        }
+        
+        public void CopyTo(Achievement[] array, int arrayIndex)
+        {
+            innerlist.CopyTo(array, arrayIndex);
+        }
+		
+		public void Dispose()
+	    {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+		}
+
+        protected virtual void Dispose(bool disposing)
+        {
+        
+        }
+		
+		public int IndexOf(Achievement item)
+        {
+            return innerlist.IndexOf(item);
+        }
+		
+		public void Insert(int index, Achievement item)
+        {
+            innerlist.Insert(index, item);
+        }
+        
+        public bool Remove(Achievement item)
+        {
+            return innerlist.Remove(item);
+        }
+        
+        public void RemoveAt(int index)
+        {
+            innerlist.RemoveAt(index);
+        }
+		
+		public IEnumerator<Achievement> GetEnumerator()
+        {
+            return innerlist.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return innerlist.GetEnumerator();
+        }
+		
+		#endregion Methods
+	}
+}
+
diff --git a/MonoGame.Framework/GamerServices/FriendCollection.cs b/MonoGame.Framework/GamerServices/FriendCollection.cs
new file mode 100644
index 00000000000..5ad5590bb9b
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/FriendCollection.cs
@@ -0,0 +1,186 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+// 
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	public class FriendCollection : IList<FriendGamer>, ICollection<FriendGamer>, IEnumerable<FriendGamer>, IEnumerable, IDisposable
+	{
+		private List<FriendGamer> innerlist;
+		
+		public FriendCollection ()
+		{
+			innerlist = new List<FriendGamer>();
+		}
+		
+        ~FriendCollection()
+        {
+            Dispose(false);
+        }
+
+		#region Properties
+		public int Count
+        {
+            get { return innerlist.Count; }
+        }
+		
+		public FriendGamer this[int index]
+        {
+            get { return innerlist[index]; }
+            set
+            {
+                if (value == null)
+                    throw new ArgumentNullException();
+
+                if (index >= innerlist.Count)
+                    throw new IndexOutOfRangeException();
+
+                /*if (innerlist[index].Position == value.Position)
+                    innerlist[index] = value;
+                else
+                {
+                    innerlist.RemoveAt(index);
+                    innerlist.Add(value);
+                }*/
+            }
+        }
+
+		private bool isReadOnly;
+		public bool IsReadOnly 
+		{
+            get
+			{
+				return isReadOnly;
+			}
+            private set 
+            {
+                isReadOnly = value;
+            }
+        }
+		
+        #endregion Properties
+		
+		#region Public Methods
+		public void Add(FriendGamer item)
+        {
+            if (item == null)
+                throw new ArgumentNullException();
+
+            if (innerlist.Count == 0)
+            {
+                innerlist.Add(item);
+                return;
+            }
+
+            for (int i = 0; i < innerlist.Count; i++)
+            {
+                /*if (item.Position < innerlist[i].Position)
+                {
+                    this.innerlist.Insert(i, item);
+                    return;
+                }*/
+            }
+
+            this.innerlist.Add(item);
+        }
+
+        public void Clear()
+        {
+            innerlist.Clear();
+        }
+		
+		public bool Contains(FriendGamer item)
+        {
+            return innerlist.Contains(item);
+        }
+        
+        public void CopyTo(FriendGamer[] array, int arrayIndex)
+        {
+            innerlist.CopyTo(array, arrayIndex);
+        }
+		
+		public void Dispose()
+	    {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+		}
+		
+        protected virtual void Dispose(bool disposing)
+        {
+
+        }
+
+		public int IndexOf(FriendGamer item)
+        {
+            return innerlist.IndexOf(item);
+        }
+		
+		public void Insert(int index, FriendGamer item)
+        {
+            innerlist.Insert(index, item);
+        }
+        
+        public bool Remove(FriendGamer item)
+        {
+            return innerlist.Remove(item);
+        }
+        
+        public void RemoveAt(int index)
+        {
+            innerlist.RemoveAt(index);
+        }
+		
+		public IEnumerator<FriendGamer> GetEnumerator()
+        {
+            return innerlist.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return innerlist.GetEnumerator();
+        }
+		
+		#endregion Methods
+	}
+}
+
diff --git a/MonoGame.Framework/GamerServices/FriendGamer.cs b/MonoGame.Framework/GamerServices/FriendGamer.cs
new file mode 100644
index 00000000000..0579e51b40c
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/FriendGamer.cs
@@ -0,0 +1,51 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+// 
+using System;
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	public class FriendGamer : Gamer
+	{
+		public FriendGamer()
+		{
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/GamerServices/GameUpdateRequiredException.cs b/MonoGame.Framework/GamerServices/GameUpdateRequiredException.cs
new file mode 100644
index 00000000000..4e8adf8ab4e
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/GameUpdateRequiredException.cs
@@ -0,0 +1,13 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    public class GameUpdateRequiredException : Exception
+    {
+
+    }
+}
diff --git a/MonoGame.Framework/GamerServices/Gamer.cs b/MonoGame.Framework/GamerServices/Gamer.cs
new file mode 100644
index 00000000000..af8bd0d852b
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/Gamer.cs
@@ -0,0 +1,154 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+using System;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    [DataContract]
+    public abstract class Gamer
+    {
+        static SignedInGamerCollection _signedInGamers = new SignedInGamerCollection();
+        string _gamer = "MonoGame";
+        Object _tag;
+        bool disposed;
+
+        LeaderboardWriter _leaderboardWriter;
+
+        #region Methods
+
+        /*
+        public IAsyncResult BeginGetProfile( AsyncCallback callback, Object asyncState )
+        {
+            throw new NotImplementedException();
+        }
+
+        public GamerProfile EndGetProfile(IAsyncResult result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public GamerProfile GetProfile()
+        {
+            throw new NotImplementedException();
+        }
+        */
+
+        public override string ToString()
+        {
+            return _gamer;
+        }
+
+        internal void Dispose()
+        {
+            disposed = true;
+        }
+
+        #endregion
+        #region Properties
+        [DataMember]
+        public string DisplayName 
+        {
+            get;
+			internal set;
+        }
+
+        [DataMember]
+        public string Gamertag 
+        {
+            get
+            {
+                return _gamer;
+            }
+			
+			internal set
+			{
+				_gamer = value;
+			}
+        }
+
+        [DataMember]
+        public bool IsDisposed
+        {
+            get
+            {
+                return disposed;
+            }
+        }
+
+        public Object Tag 
+        {
+            get
+            {
+                return _tag;
+            }
+            set
+            {
+                if (_tag != value)
+                {
+                    _tag = value;
+                }
+            }
+        }
+
+        public static SignedInGamerCollection SignedInGamers
+        {
+            get
+            {
+                return _signedInGamers;
+            }
+        }
+
+        public LeaderboardWriter LeaderboardWriter 
+        { 
+            get
+            {
+                return _leaderboardWriter;
+            }
+
+            internal set 
+            {
+                _leaderboardWriter = value;
+            }
+        }
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/GamerServices/GamerCollection.cs b/MonoGame.Framework/GamerServices/GamerCollection.cs
new file mode 100644
index 00000000000..869af291132
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/GamerCollection.cs
@@ -0,0 +1,97 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License 
+
+#region Using clause
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+
+
+	public class GamerCollection<T> : ReadOnlyCollection<T>, IEnumerable<T>, IEnumerable where T : Gamer
+	{	
+		internal GamerCollection(List<T> list): base(list)
+		{
+		}
+		
+		internal GamerCollection(): base(new List<T>())
+		{
+		}
+ 
+		internal void AddGamer (T item) {
+            // need to add gamers at the correct index based on GamerTag           
+            if (base.Items.Count > 0)
+            {
+                for (int i = 0; i < base.Items.Count; i++)
+                {
+                    if (item.Gamertag.CompareTo(base.Items[i].Gamertag) > 0)
+                    {
+                        base.Items.Insert(i, item);
+                        return;
+                    }
+                }
+            }
+            base.Items.Add(item);            
+            
+		}
+		
+		internal void RemoveGamer (T item) {
+			base.Items.Remove (item);
+		}		
+
+		internal void RemoveGamerAt (int item) {
+			base.Items.RemoveAt (item);
+		}		
+		
+//	public IEnumerator<Gamer> GetEnumerator()
+//        {
+//            return this.GetEnumerator();
+//        }
+		
+	    IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+	}
+}
diff --git a/MonoGame.Framework/GamerServices/GamerDefaults.cs b/MonoGame.Framework/GamerServices/GamerDefaults.cs
new file mode 100644
index 00000000000..e6a5d8ac0be
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/GamerDefaults.cs
@@ -0,0 +1,55 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License 
+
+using System;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	public sealed class GameDefaults
+	{
+		public bool AccelerateWithButtons 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+	}
+}
diff --git a/MonoGame.Framework/GamerServices/GamerPresence.cs b/MonoGame.Framework/GamerServices/GamerPresence.cs
new file mode 100644
index 00000000000..c9d7149c390
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/GamerPresence.cs
@@ -0,0 +1,71 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License 
+
+using System;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	public sealed class GamerPresence
+	{
+		public GamerPresenceMode PresenceMode 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+			set
+			{
+				throw new NotSupportedException();
+			}
+		}
+		
+		public int PresenceValue
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+			set
+			{
+				throw new NotSupportedException();
+			}
+		}
+	}
+}
diff --git a/MonoGame.Framework/GamerServices/GamerPresenceMode.cs b/MonoGame.Framework/GamerServices/GamerPresenceMode.cs
new file mode 100644
index 00000000000..99b11e8b44b
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/GamerPresenceMode.cs
@@ -0,0 +1,108 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License 
+
+using System;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	public enum GamerPresenceMode
+	{
+		ArcadeMode, //Arcade Mode
+		AtMenu, //At Menu
+		BattlingBoss	, //Battling Boss
+		CampaignMode, //	Campaign Mode
+		ChallengeMode, //	Challenge Mode
+		ConfiguringSettings, // // Configuring Settings
+		CoOpLevel, //	Co-Op: Level. Includes a numeric value specified with PresenceValue.
+		CoOpStage,// 	Co-Op: Stage. Includes a numeric value specified with PresenceValue.
+		CornflowerBlue, //Cornflower Blue
+		CustomizingPlayer, //Customizing Player
+		DifficultyEasy, //Difficulty: Easy
+		DifficultyExtreme, //Difficulty: Extreme
+		DifficultyHard, //Difficulty: Hard
+		DifficultyMedium	, // Difficulty: Medium
+		EditingLevel	, // Editing Level
+		ExplorationMode, //Exploration Mode
+		FoundSecret, //Found Secret
+		FreePlay	, // Free Play
+		GameOver	, //Game Over
+		InCombat, 	// In Combat
+		InGameStore, //In Game Store
+		Level, //Level. Includes a numeric value specified with PresenceValue.
+		LocalCoOp, //Local Co-Op
+		LocalVersus, //Local Versus
+		LookingForGames, //Looking For Games
+		Losing, //Losing
+		Multiplayer, //Multiplayer
+		NearlyFinished, // Nearly Finished
+		None	, // NoPresence String Displayed
+		OnARoll, // On a Roll
+		OnlineCoOp, //Online Co-Op
+		OnlineVersus, //Online Versus
+		Outnumbered, //Outnumbered
+		Paused, //Paused
+		PlayingMinigame, //Playing Minigame
+		PlayingWithFriends, //Playing With Friends
+		PracticeMode	, //Practice Mode
+		PuzzleMode, //Puzzle Mode
+		ScenarioMode	, //Scenario Mode
+		Score, //Score. Includes a numeric value specified with PresenceValue.
+		ScoreIsTied, //Score is Tied
+		SettingUpMatch, //Setting Up Match
+		SinglePlayer, //	Single Player
+		Stage, //Stage. Includes a numeric value specified with PresenceValue.
+		StartingGame, //Starting Game
+		StoryMode, //Story Mode
+		StuckOnAHardBit, //	Stuck on a Hard Bit
+		SurvivalMode	, //Survival Mode
+		TimeAttack, //Time Attack
+		TryingForRecord, //	Trying For Record
+		TutorialMode	, //Tutorial Mode
+		VersusComputer, //Versus Computer
+		VersusScore, //	Versus: Score. Includes a numeric value specified with PresenceValue.
+		WaitingForPlayers, //Waiting For Players
+		WaitingInLobby, //Waiting In Lobby
+		WastingTime, //	Wasting Time
+		WatchingCredits, //	Watching Credits
+		WatchingCutscene, //Watching Cutscene
+		Winning, //	Winning
+		WonTheGame, //	Won the Game
+	}
+}
diff --git a/MonoGame.Framework/GamerServices/GamerPrivilegeSetting.cs b/MonoGame.Framework/GamerServices/GamerPrivilegeSetting.cs
new file mode 100644
index 00000000000..f4b294797c5
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/GamerPrivilegeSetting.cs
@@ -0,0 +1,52 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+
+using System;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	public enum GamerPrivilegeSetting
+	{
+		Blocked,		// This privilege is not available for the current gamer profile.
+		Everyone,		// This privilege is available for the current gamer profile.
+		FriendsOnly,	// This privilege is only available for friends of the current gamer profile. Use the IsFriend method to check which gamers are friends. 	
+	}
+}
diff --git a/MonoGame.Framework/GamerServices/GamerPrivileges.cs b/MonoGame.Framework/GamerServices/GamerPrivileges.cs
new file mode 100644
index 00000000000..2d08b9e7b36
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/GamerPrivileges.cs
@@ -0,0 +1,111 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+
+using System;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+#if WINDOWS_UAP
+    [DataContract]
+#else
+    [Serializable]
+#endif
+    public class GamerPrivilegeException : Exception
+	{
+		
+	}
+	
+    public class GamerPrivileges
+    {
+		#region Properties
+		public GamerPrivilegeSetting AllowCommunication 
+		{ 
+			get
+			{
+				return GamerPrivilegeSetting.Everyone;
+			}
+		}
+		
+		public bool AllowOnlineSessions 
+		{ 
+			get
+			{
+				return true;
+			}
+		}
+		
+		public GamerPrivilegeSetting AllowProfileViewing 
+		{ 
+			get
+			{
+				return GamerPrivilegeSetting.Blocked;
+			}
+		}
+		
+		public bool AllowPurchaseContent
+		{ 
+			get
+			{
+				return false;
+			}
+		}
+		
+		public bool AllowTradeContent 
+		{ 
+			get
+			{
+				return false;
+			} 
+		}
+		
+		public GamerPrivilegeSetting AllowUserCreatedContent 
+		{ 
+			get
+			{
+				return GamerPrivilegeSetting.Blocked;
+			} 
+		}
+		#endregion
+		
+        
+    }
+}
diff --git a/MonoGame.Framework/GamerServices/GamerProfile.cs b/MonoGame.Framework/GamerServices/GamerProfile.cs
new file mode 100644
index 00000000000..7fb558017d9
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/GamerProfile.cs
@@ -0,0 +1,133 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+#region Using Statements
+using System;
+using System.Globalization;
+
+using Microsoft.Xna.Framework.Graphics;
+
+#endregion
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	
+	public sealed class GamerProfile : IDisposable
+    {
+        ~GamerProfile()
+        {
+            Dispose(false);
+        }
+
+        #region IDisposable implementation
+
+        public void Dispose()
+		{
+            Dispose(true);
+            GC.SuppressFinalize(this);
+		}
+
+        private void Dispose(bool disposing)
+        {
+        }
+
+	    #endregion
+
+	#region Properties
+
+        /*
+		public Texture2D GamerPicture {
+			get {
+				throw new NotImplementedException ();
+			}
+		}
+		
+		public int GamerScore {
+			get {
+				throw new NotImplementedException ();
+			}
+		}
+
+		public GamerZone GamerZone {
+			get {
+				throw new NotImplementedException ();
+			}
+		}
+
+		public bool IsDisposed {
+			get {
+				throw new NotImplementedException ();
+			}
+		}
+
+		public string Motto {
+			get {
+				throw new NotImplementedException ();
+			}
+		}
+
+		public RegionInfo Region {
+			get {
+				throw new NotImplementedException ();
+			}
+		}
+
+		public float Reputation {
+			get {
+				throw new NotImplementedException ();
+			}
+		}
+
+		public int TitlesPlayed {
+			get {
+				throw new NotImplementedException ();
+			}
+		}
+
+		public int TotalAchievements {
+			get {
+				throw new NotImplementedException ();
+			}
+		}
+        */
+
+	#endregion
+	}
+}
diff --git a/MonoGame.Framework/GamerServices/GamerServicesComponent.cs b/MonoGame.Framework/GamerServices/GamerServicesComponent.cs
new file mode 100644
index 00000000000..0787cb86553
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/GamerServicesComponent.cs
@@ -0,0 +1,103 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009-2012 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+1. Definitions
+
+The terms "reproduce," "reproduction," "derivative works," and "distribution"
+have the same meaning here as under U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the
+software.
+
+A "contributor" is any person that distributes its contribution under this
+license.
+
+"Licensed patents" are a contributor's patent claims that read directly on its
+contribution.
+
+2. Grant of Rights
+
+(A) Copyright Grant- Subject to the terms of this license, including the
+license conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free copyright license to reproduce its
+contribution, prepare derivative works of its contribution, and distribute its
+contribution or any derivative works that you create.
+
+(B) Patent Grant- Subject to the terms of this license, including the license
+conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free license under its licensed patents to
+make, have made, use, sell, offer for sale, import, and/or otherwise dispose of
+its contribution in the software or derivative works of the contribution in the
+software.
+
+3. Conditions and Limitations
+
+(A) No Trademark License- This license does not grant you rights to use any
+contributors' name, logo, or trademarks.
+
+(B) If you bring a patent claim against any contributor over patents that you
+claim are infringed by the software, your patent license from such contributor
+to the software ends automatically.
+
+(C) If you distribute any portion of the software, you must retain all
+copyright, patent, trademark, and attribution notices that are present in the
+software.
+
+(D) If you distribute any portion of the software in source code form, you may
+do so only under this license by including a complete copy of this license with
+your distribution. If you distribute any portion of the software in compiled or
+object code form, you may only do so under a license that complies with this
+license.
+
+(E) The software is licensed "as-is." You bear the risk of using it. The
+contributors give no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the contributors exclude
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.
+*/
+#endregion License
+
+
+#region Using Statements
+using System;
+
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Net;
+#endregion Statements
+
+namespace Microsoft.Xna.Framework.GamerServices {
+
+	public class GamerServicesComponent : GameComponent {
+		private static LocalNetworkGamer lng;
+
+		internal static LocalNetworkGamer LocalNetworkGamer { get { return lng; } set { lng = value; } }
+
+		public GamerServicesComponent(Game game)
+			: base(game)
+		{
+            Guide.Initialise(game);
+		}
+
+		public override void Update (GameTime gameTime)
+		{
+
+		}
+	}
+
+    public class MonoGameGamerServicesComponent : GamerServicesComponent
+    {
+        public MonoGameGamerServicesComponent(Game game): base (game)
+        {
+
+        }
+    }
+}
diff --git a/MonoGame.Framework/GamerServices/GamerServicesDispatcher.cs b/MonoGame.Framework/GamerServices/GamerServicesDispatcher.cs
new file mode 100644
index 00000000000..b46e11f76c4
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/GamerServicesDispatcher.cs
@@ -0,0 +1,69 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+using System;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    public static class GamerServicesDispatcher
+    {
+        /*
+        public static void Initialize ( IServiceProvider serviceProvider )
+        {
+            throw new NotImplementedException();   
+        }
+        */
+
+        public static void Update ()
+        {            
+        }
+
+        public static bool IsInitialized { get { return false;  } }
+
+        public static IntPtr WindowHandle { get; set; }
+
+        public static event EventHandler<EventArgs> InstallingTitleUpdate;
+
+		private static bool SuppressEventHandlerWarningsUntilEventsAreProperlyImplemented()
+		{
+			return InstallingTitleUpdate != null;
+		}
+    }
+}
diff --git a/MonoGame.Framework/GamerServices/GamerZone.cs b/MonoGame.Framework/GamerServices/GamerZone.cs
new file mode 100644
index 00000000000..fabb6af5f9d
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/GamerZone.cs
@@ -0,0 +1,55 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+#region Using Statements
+using System;
+#endregion
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    public enum GamerZone
+    {
+        Family,	        // Family-friendly game play.
+	    Pro,	        // Competitive game play.
+	    Recreation,     // Non-competitive game play.
+	    Underground,    // Alternative approach to game play.
+	    Unknown,        // Unknown.
+    }
+}
diff --git a/MonoGame.Framework/GamerServices/GuideAlreadyVisibleException.cs b/MonoGame.Framework/GamerServices/GuideAlreadyVisibleException.cs
new file mode 100644
index 00000000000..fc3727353f6
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/GuideAlreadyVisibleException.cs
@@ -0,0 +1,64 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+using System;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    [DataContract]
+    public class GuideAlreadyVisibleException : Exception
+	{
+
+		public GuideAlreadyVisibleException ()
+		{
+		}
+		
+		public GuideAlreadyVisibleException( string message )
+		{
+			
+		}
+
+        public GuideAlreadyVisibleException(string message, Exception innerException)
+		{
+			
+		}
+	}
+}
diff --git a/MonoGame.Framework/GamerServices/LeaderboardEntry.cs b/MonoGame.Framework/GamerServices/LeaderboardEntry.cs
new file mode 100644
index 00000000000..ca1eedc4da9
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/LeaderboardEntry.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    [DataContract]
+    public sealed class LeaderboardEntry
+    {
+
+        [DataMember]
+        public long Rating { get; set; }
+
+        [DataMember]
+        public PropertyDictionary Columns { get; internal set; }
+
+        [DataMember]
+        public Gamer Gamer { get; internal set; }
+
+        public LeaderboardEntry ()
+        {
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/GamerServices/LeaderboardIdentity.cs b/MonoGame.Framework/GamerServices/LeaderboardIdentity.cs
new file mode 100644
index 00000000000..af583427b32
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/LeaderboardIdentity.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    [DataContract]
+    public struct LeaderboardIdentity
+    {
+        [DataMember]
+        public int GameMode { get; set; }
+
+        [DataMember]
+        public LeaderboardKey Key { get; set; }
+
+        public static LeaderboardIdentity Create(LeaderboardKey aKey)
+        {
+            return new LeaderboardIdentity() { Key = aKey};
+        }
+
+        public static LeaderboardIdentity Create(LeaderboardKey aKey, int aGameMode)
+        {
+            return new LeaderboardIdentity() { Key = aKey, GameMode = aGameMode};
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/GamerServices/LeaderboardKey.cs b/MonoGame.Framework/GamerServices/LeaderboardKey.cs
new file mode 100644
index 00000000000..831d2c964dd
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/LeaderboardKey.cs
@@ -0,0 +1,13 @@
+using System;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    public enum LeaderboardKey
+    {
+        BestScoreLifeTime,
+        BestScoreRecent,
+        BestTimeLifeTime,
+        BestTimeRecent,
+    }
+}
+
diff --git a/MonoGame.Framework/GamerServices/LeaderboardReader.cs b/MonoGame.Framework/GamerServices/LeaderboardReader.cs
new file mode 100644
index 00000000000..b37d05e38f1
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/LeaderboardReader.cs
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    public sealed class LeaderboardReader : IDisposable
+    {
+        public LeaderboardReader ()
+        {
+        }
+
+        /*
+        public IAsyncResult BeginPageDown(AsyncCallback aAsyncCallback, object aAsyncState)
+        {
+            throw new NotImplementedException ();
+        }
+
+        public IAsyncResult BeginPageUp(AsyncCallback aAsyncCallback, object aAsyncState)
+        {
+            throw new NotImplementedException ();
+        }
+
+        public LeaderboardReader EndPageDown(IAsyncResult result)
+        {
+            throw new NotImplementedException ();
+        }
+
+        public LeaderboardReader EndPageUp(IAsyncResult result)
+        {
+            throw new NotImplementedException ();
+        }
+
+        public static void BeginRead (LeaderboardIdentity id, SignedInGamer gamer, int leaderboardPageSize, AsyncCallback leaderboardReadCallback, SignedInGamer gamer2)
+        {
+            throw new NotImplementedException ();
+        }
+
+        public static LeaderboardReader EndRead(IAsyncResult result)
+        {
+            throw new NotImplementedException ();
+        }
+
+        public void PageDown()
+        {
+            throw new NotImplementedException ();
+        }
+
+        public void PageUp()
+        {
+            throw new NotImplementedException ();
+        }
+        */
+
+        public bool CanPageDown {
+            get;
+            set;
+        }
+
+        public bool CanPageUp {
+            get;
+            set;
+        }
+
+        public IEnumerable<LeaderboardEntry> Entries {
+            get;
+            set;
+        }
+
+        #region IDisposable implementation
+
+        public void Dispose ()
+        {
+            throw new NotImplementedException ();
+        }
+
+        #endregion
+    }
+}
+
diff --git a/MonoGame.Framework/GamerServices/LeaderboardWriter.cs b/MonoGame.Framework/GamerServices/LeaderboardWriter.cs
new file mode 100644
index 00000000000..5a908a383ef
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/LeaderboardWriter.cs
@@ -0,0 +1,28 @@
+using System;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    public sealed class LeaderboardWriter : IDisposable
+    {
+        public LeaderboardWriter ()
+        {
+        }
+
+        /*
+        public LeaderboardEntry GetLeaderboard(LeaderboardIdentity aLeaderboardIdentity)
+        {
+            throw new NotImplementedException ();
+        }
+        */
+
+        #region IDisposable implementation
+
+        void IDisposable.Dispose ()
+        {
+            throw new NotImplementedException ();
+        }
+
+        #endregion
+    }
+}
+
diff --git a/MonoGame.Framework/GamerServices/MessageBoxIcon.cs b/MonoGame.Framework/GamerServices/MessageBoxIcon.cs
new file mode 100644
index 00000000000..0c59df3ba62
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/MessageBoxIcon.cs
@@ -0,0 +1,52 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+// 
+using System;
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	public enum MessageBoxIcon
+	{
+		Alert,		// Displays the Alert icon.
+		Error,		// Displays the Error icon.
+		None,		// No icon is displayed.
+		Warning,	// Displays the Warning icon.
+	}
+}
+
diff --git a/MonoGame.Framework/GamerServices/NotificationPosition.cs b/MonoGame.Framework/GamerServices/NotificationPosition.cs
new file mode 100644
index 00000000000..26df6ca45ca
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/NotificationPosition.cs
@@ -0,0 +1,83 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009-2012 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+1. Definitions
+
+The terms "reproduce," "reproduction," "derivative works," and "distribution"
+have the same meaning here as under U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the
+software.
+
+A "contributor" is any person that distributes its contribution under this
+license.
+
+"Licensed patents" are a contributor's patent claims that read directly on its
+contribution.
+
+2. Grant of Rights
+
+(A) Copyright Grant- Subject to the terms of this license, including the
+license conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free copyright license to reproduce its
+contribution, prepare derivative works of its contribution, and distribute its
+contribution or any derivative works that you create.
+
+(B) Patent Grant- Subject to the terms of this license, including the license
+conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free license under its licensed patents to
+make, have made, use, sell, offer for sale, import, and/or otherwise dispose of
+its contribution in the software or derivative works of the contribution in the
+software.
+
+3. Conditions and Limitations
+
+(A) No Trademark License- This license does not grant you rights to use any
+contributors' name, logo, or trademarks.
+
+(B) If you bring a patent claim against any contributor over patents that you
+claim are infringed by the software, your patent license from such contributor
+to the software ends automatically.
+
+(C) If you distribute any portion of the software, you must retain all
+copyright, patent, trademark, and attribution notices that are present in the
+software.
+
+(D) If you distribute any portion of the software in source code form, you may
+do so only under this license by including a complete copy of this license with
+your distribution. If you distribute any portion of the software in compiled or
+object code form, you may only do so under a license that complies with this
+license.
+
+(E) The software is licensed "as-is." You bear the risk of using it. The
+contributors give no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the contributors exclude
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.
+*/
+#endregion License
+
+using System;
+
+namespace Microsoft.Xna.Framework.GamerServices {
+	public enum NotificationPosition {
+		TopLeft,
+		TopCenter,
+		TopRight,
+		CenterLeft,
+		Center,
+		CenterRight,
+		BottomLeft,
+		BottomCenter,
+		BottomRight
+	}
+}
diff --git a/MonoGame.Framework/GamerServices/PropertyDictionary.cs b/MonoGame.Framework/GamerServices/PropertyDictionary.cs
new file mode 100644
index 00000000000..75992ee03c3
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/PropertyDictionary.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    public class PropertyDictionary
+    {
+        private Dictionary<string,object> PropDictionary = new Dictionary<string, object>();
+        public int GetValueInt32 (string aKey)
+        {
+            return (int)PropDictionary[aKey];
+        }
+
+        public DateTime GetValueDateTime (string aKey)
+        {
+            return (DateTime)PropDictionary[aKey];
+        }
+
+        public void SetValue(string aKey, DateTime aValue)
+        {
+            if(PropDictionary.ContainsKey(aKey))
+            {
+                PropDictionary[aKey] = aValue;
+            }
+            else
+            {
+                PropDictionary.Add(aKey,aValue);
+            }
+        }
+    }
+
+}
+
diff --git a/MonoGame.Framework/GamerServices/SignedInGamerCollection.cs b/MonoGame.Framework/GamerServices/SignedInGamerCollection.cs
new file mode 100644
index 00000000000..0b4e1fa3f58
--- /dev/null
+++ b/MonoGame.Framework/GamerServices/SignedInGamerCollection.cs
@@ -0,0 +1,61 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	public class SignedInGamerCollection : List<SignedInGamer>
+	{
+		#region Properties
+		// Indexer to get and set words of the containing document:
+		public SignedInGamer this [PlayerIndex index] { 
+			get {
+				if (this.Count == 0 || (int)index > this.Count - 1)
+					return null;
+
+				return this [(int)index];
+			}
+		}
+		#endregion
+	}
+
+
+}
diff --git a/MonoGame.Framework/Graphics/ClearOptions.cs b/MonoGame.Framework/Graphics/ClearOptions.cs
new file mode 100644
index 00000000000..f580572446a
--- /dev/null
+++ b/MonoGame.Framework/Graphics/ClearOptions.cs
@@ -0,0 +1,29 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines the buffers for clearing when calling <see cref="GraphicsDevice.Clear(ClearOptions, Color, float, int)"/> operation.
+    /// </summary>
+    [Flags]
+    public enum ClearOptions
+    {
+        /// <summary>
+        /// Color buffer.
+        /// </summary>
+		Target = 1,
+        /// <summary>
+        /// Depth buffer.
+        /// </summary>
+        DepthBuffer = 2,
+        /// <summary>
+        /// Stencil buffer.
+        /// </summary>
+        Stencil = 4        
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/ColorWriteChannels.cs b/MonoGame.Framework/Graphics/ColorWriteChannels.cs
new file mode 100644
index 00000000000..a0922c631de
--- /dev/null
+++ b/MonoGame.Framework/Graphics/ColorWriteChannels.cs
@@ -0,0 +1,40 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines the color channels for render target blending operations.
+    /// </summary>
+	[Flags]
+	public enum ColorWriteChannels
+	{
+        /// <summary>
+        /// No channels selected.
+        /// </summary>
+		None = 0,
+        /// <summary>
+        /// Red channel selected.
+        /// </summary>
+		Red = 1,
+        /// <summary>
+        /// Green channel selected.
+        /// </summary>
+		Green = 2,
+        /// <summary>
+        /// Blue channel selected.
+        /// </summary>
+		Blue = 4,
+        /// <summary>
+        /// Alpha channel selected.
+        /// </summary>
+		Alpha = 8,
+        /// <summary>
+        /// All channels selected.
+        /// </summary>
+		All = 15
+	}
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/CubeMapFace.cs b/MonoGame.Framework/Graphics/CubeMapFace.cs
new file mode 100644
index 00000000000..721d7ed2229
--- /dev/null
+++ b/MonoGame.Framework/Graphics/CubeMapFace.cs
@@ -0,0 +1,38 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines the faces in a cube map for the <see cref="TextureCube"/> class.
+    /// </summary>
+	public enum CubeMapFace
+    {
+        /// <summary>
+        /// Positive X face in the cube map.
+        /// </summary>
+		PositiveX,
+        /// <summary>
+        /// Negative X face in the cube map.
+        /// </summary>
+        NegativeX, 
+        /// <summary>
+        /// Positive Y face in the cube map.
+        /// </summary>
+        PositiveY,
+        /// <summary>
+        /// Negative Y face in the cube map.
+        /// </summary>
+        NegativeY,
+        /// <summary>
+        /// Positive Z face in the cube map.
+        /// </summary>
+        PositiveZ,
+        /// <summary>
+        /// Negative Z face in the cube map.
+        /// </summary>
+		NegativeZ
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/DeviceLostException.cs b/MonoGame.Framework/Graphics/DeviceLostException.cs
new file mode 100644
index 00000000000..3801deb47f4
--- /dev/null
+++ b/MonoGame.Framework/Graphics/DeviceLostException.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    [DataContract]
+    public sealed class DeviceLostException : Exception
+    {
+        public DeviceLostException()
+            : base()
+        {
+
+        }
+
+        public DeviceLostException(string message)
+            : base(message)
+        {
+
+        }
+
+        public DeviceLostException(string message, Exception inner)
+            : base(message, inner)
+        {
+
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/DeviceNotResetException.cs b/MonoGame.Framework/Graphics/DeviceNotResetException.cs
new file mode 100644
index 00000000000..8bec4ec03d7
--- /dev/null
+++ b/MonoGame.Framework/Graphics/DeviceNotResetException.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    [DataContract]
+    public sealed class DeviceNotResetException : Exception
+    {
+        public DeviceNotResetException()
+            : base()
+        {
+
+        }
+
+        public DeviceNotResetException(string message)
+            : base(message)
+        {
+
+        }
+
+        public DeviceNotResetException(string message, Exception inner)
+            : base(message, inner)
+        {
+
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/DirectionalLight.cs b/MonoGame.Framework/Graphics/DirectionalLight.cs
new file mode 100644
index 00000000000..7dd8fbd0d68
--- /dev/null
+++ b/MonoGame.Framework/Graphics/DirectionalLight.cs
@@ -0,0 +1,142 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+// 
+using System;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public sealed class DirectionalLight
+	{
+		internal EffectParameter diffuseColorParameter;
+		internal EffectParameter directionParameter;
+		internal EffectParameter specularColorParameter;
+		
+		Vector3 diffuseColor;
+		Vector3 direction;
+		Vector3 specularColor;
+		bool enabled;
+		
+		public DirectionalLight (EffectParameter directionParameter, EffectParameter diffuseColorParameter, EffectParameter specularColorParameter, DirectionalLight cloneSource)
+		{
+			this.diffuseColorParameter = diffuseColorParameter;
+			this.directionParameter = directionParameter;
+			this.specularColorParameter = specularColorParameter;
+			if (cloneSource != null) {
+				this.diffuseColor = cloneSource.diffuseColor;
+				this.direction = cloneSource.direction;
+				this.specularColor = cloneSource.specularColor;
+				this.enabled = cloneSource.enabled;
+			} else {
+				this.diffuseColorParameter = diffuseColorParameter;
+				this.directionParameter = directionParameter;
+				this.specularColorParameter = specularColorParameter;
+			}
+		}
+		
+		public Vector3 DiffuseColor {
+			get {
+				return diffuseColor;
+			}
+			set {
+				diffuseColor = value;
+				if (this.enabled && this.diffuseColorParameter != null)
+					diffuseColorParameter.SetValue (diffuseColor);
+			}
+		}
+		
+		public Vector3 Direction {
+			get {
+				return direction;
+			}
+			set {
+				direction = value;
+				if (this.directionParameter != null)
+					directionParameter.SetValue (direction);
+			}
+		}
+		
+		public Vector3 SpecularColor {
+			get {
+				return specularColor;
+			}
+			set {
+				specularColor = value;
+				if (this.enabled && this.specularColorParameter != null)
+					specularColorParameter.SetValue (specularColor);
+			}
+		}
+		public bool Enabled 
+		{
+			get { return enabled; }
+			set 
+			{
+				if (this.enabled != value)
+				{
+				    this.enabled = value;
+				    if (this.enabled)
+				    {
+				        if (this.diffuseColorParameter != null)
+				        {
+				            this.diffuseColorParameter.SetValue(this.diffuseColor);
+				        }
+				        if (this.specularColorParameter != null)
+				        {
+				            this.specularColorParameter.SetValue(this.specularColor);
+				        }
+				    }
+				    else
+				    {
+				        if (this.diffuseColorParameter != null)
+				        {
+				            this.diffuseColorParameter.SetValue(Vector3.Zero);
+				        }
+				        if (this.specularColorParameter != null)
+				        {
+				            this.specularColorParameter.SetValue(Vector3.Zero);
+				        }
+				    }
+				}
+
+			}
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/DisplayMode.cs b/MonoGame.Framework/Graphics/DisplayMode.cs
new file mode 100644
index 00000000000..d44ca18f411
--- /dev/null
+++ b/MonoGame.Framework/Graphics/DisplayMode.cs
@@ -0,0 +1,126 @@
+#region License
+/*
+MIT License
+Copyright © 2006 The Mono.Xna Team
+
+All rights reserved.
+
+Authors:
+ * Rob Loach
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+#endregion License
+
+using System;
+using System.Globalization;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    [DataContract]
+    public class DisplayMode
+    {
+        #region Fields
+
+        private SurfaceFormat format;
+        private int height;
+        private int width;
+
+        #endregion Fields
+
+        #region Properties
+        
+        public float AspectRatio {
+            get { return (float)width / (float)height; }
+        }
+
+        public SurfaceFormat Format {
+            get { return format; }
+        }
+
+        public int Height {
+            get { return this.height; }
+        }
+
+        public int Width {
+            get { return this.width; }
+        }
+        
+        public Rectangle TitleSafeArea {
+            get { return GraphicsDevice.GetTitleSafeArea(0, 0, width, height); }
+        }
+
+        #endregion Properties
+
+        #region Constructors
+        
+        internal DisplayMode(int width, int height, SurfaceFormat format)
+        {
+            this.width = width;
+            this.height = height;
+            this.format = format;
+        }
+
+        #endregion Constructors
+
+        #region Operators
+
+        public static bool operator !=(DisplayMode left, DisplayMode right)
+        {
+            return !(left == right);
+        }
+
+        public static bool operator ==(DisplayMode left, DisplayMode right)
+        {
+            if (ReferenceEquals(left, right)) //Same object or both are null
+            {
+                return true;
+            }
+            if (ReferenceEquals(left, null) || ReferenceEquals(right, null))
+            {
+                return false;
+            }
+            return (left.format == right.format) &&
+                (left.height == right.height) &&
+                (left.width == right.width);
+        }
+
+        #endregion Operators
+
+        #region Public Methods
+
+        public override bool Equals(object obj)
+        {
+            return obj is DisplayMode && this == (DisplayMode)obj;
+        }
+
+        public override int GetHashCode()
+        {
+            return (this.width.GetHashCode() ^ this.height.GetHashCode() ^ this.format.GetHashCode());
+        }
+
+        public override string ToString()
+        {
+            return "{Width:" + this.width + " Height:" + this.height + " Format:" + this.Format + " AspectRatio:" + this.AspectRatio + "}";
+        }
+
+        #endregion Public Methods
+    }
+}
diff --git a/MonoGame.Framework/Graphics/DisplayModeCollection.cs b/MonoGame.Framework/Graphics/DisplayModeCollection.cs
new file mode 100644
index 00000000000..06bb66f3dfb
--- /dev/null
+++ b/MonoGame.Framework/Graphics/DisplayModeCollection.cs
@@ -0,0 +1,81 @@
+#region License
+
+/*
+MIT License
+Copyright © 2006 The Mono.Xna Team
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#endregion License
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public class DisplayModeCollection : IEnumerable<DisplayMode>
+    {
+        private readonly List<DisplayMode> _modes;
+
+        public IEnumerable<DisplayMode> this[SurfaceFormat format]
+        {
+            get 
+            {
+                var list = new List<DisplayMode>();
+                foreach (var mode in _modes)
+                {
+                    if (mode.Format == format)
+                        list.Add(mode);
+                }
+                return list;
+            }
+        }
+
+        public IEnumerator<DisplayMode> GetEnumerator()
+        {
+            return _modes.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return _modes.GetEnumerator();
+        }
+        
+        internal DisplayModeCollection(List<DisplayMode> modes) 
+        {
+            // Sort the modes in a consistent way that happens
+            // to match XNA behavior on some graphics devices.
+
+            modes.Sort(delegate(DisplayMode a, DisplayMode b)
+            {
+                if (a == b) 
+                    return 0;
+                if (a.Format <= b.Format && a.Width <= b.Width && a.Height <= b.Height) 
+                    return -1;
+                return 1;
+            });
+
+            _modes = modes;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/DxtUtil.cs b/MonoGame.Framework/Graphics/DxtUtil.cs
new file mode 100644
index 00000000000..3cff04dba15
--- /dev/null
+++ b/MonoGame.Framework/Graphics/DxtUtil.cs
@@ -0,0 +1,443 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+// 
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	internal static class DxtUtil
+	{
+		internal static byte[] DecompressDxt1(byte[] imageData, int width, int height)
+        {
+            using (MemoryStream imageStream = new MemoryStream(imageData))
+                return DecompressDxt1(imageStream, width, height);
+        }
+
+        internal static byte[] DecompressDxt1(Stream imageStream, int width, int height)
+        {
+            byte[] imageData = new byte[width * height * 4];
+
+            using (BinaryReader imageReader = new BinaryReader(imageStream))
+            {
+                int blockCountX = (width + 3) / 4;
+                int blockCountY = (height + 3) / 4;
+                
+                for (int y = 0; y < blockCountY; y++)
+                {
+                    for (int x = 0; x < blockCountX; x++)
+                    {
+						DecompressDxt1Block(imageReader, x, y, blockCountX, width, height, imageData);
+					}
+                }
+            }
+
+            return imageData;
+        }
+
+        private static void DecompressDxt1Block(BinaryReader imageReader, int x, int y, int blockCountX, int width, int height, byte[] imageData)
+        {
+            ushort c0 = imageReader.ReadUInt16();
+            ushort c1 = imageReader.ReadUInt16();
+
+			byte r0, g0, b0;
+			byte r1, g1, b1;
+            ConvertRgb565ToRgb888(c0, out r0, out g0, out b0);
+			ConvertRgb565ToRgb888(c1, out r1, out g1, out b1);
+
+            uint lookupTable = imageReader.ReadUInt32();
+
+            for (int blockY = 0; blockY < 4; blockY++)
+            {
+                for (int blockX = 0; blockX < 4; blockX++)
+                {
+					byte r = 0, g = 0, b = 0, a = 255;
+                    uint index = (lookupTable >> 2 * (4 * blockY + blockX)) & 0x03;
+                    
+                    if (c0 > c1)
+                    {
+                        switch (index)
+                        {
+							case 0:
+								r = r0;
+								g = g0;
+								b = b0;
+								break;
+							case 1:
+								r = r1;
+								g = g1;
+								b = b1;
+								break;
+                            case 2:
+								r = (byte)((2 * r0 + r1) / 3);
+								g = (byte)((2 * g0 + g1) / 3);
+								b = (byte)((2 * b0 + b1) / 3);
+								break;
+                            case 3:
+								r = (byte)((r0 + 2 * r1) / 3);
+								g = (byte)((g0 + 2 * g1) / 3);
+								b = (byte)((b0 + 2 * b1) / 3);
+								break;
+                        }
+                    }
+                    else
+                    {
+                        switch (index)
+                        {
+							case 0:
+								r = r0;
+								g = g0;
+								b = b0;
+								break;
+							case 1:
+								r = r1;
+								g = g1;
+								b = b1;
+								break;
+							case 2:
+								r = (byte)((r0 + r1) / 2);
+								g = (byte)((g0 + g1) / 2);
+								b = (byte)((b0 + b1) / 2);
+								break;
+							case 3:
+								r = 0;
+								g = 0;
+								b = 0;
+								a = 0;
+								break;
+                        }
+                    }
+
+					int px = (x << 2) + blockX;
+					int py = (y << 2) + blockY;
+					if ((px < width) && (py < height))
+					{
+						int offset = ((py * width) + px) << 2;
+						imageData[offset] = r;
+						imageData[offset + 1] = g;
+						imageData[offset + 2] = b;
+						imageData[offset + 3] = a;
+					}
+                }
+			}
+        }
+        
+        internal static byte[] DecompressDxt3(byte[] imageData, int width, int height)
+        {
+            using (MemoryStream imageStream = new MemoryStream(imageData))
+                return DecompressDxt3(imageStream, width, height);
+        }
+
+        internal static byte[] DecompressDxt3(Stream imageStream, int width, int height)
+        {
+            byte[] imageData = new byte[width * height * 4];
+
+            using (BinaryReader imageReader = new BinaryReader(imageStream))
+            {
+                int blockCountX = (width + 3) / 4;
+                int blockCountY = (height + 3) / 4;
+
+                for (int y = 0; y < blockCountY; y++)
+                {
+                    for (int x = 0; x < blockCountX; x++)
+                    {
+                        DecompressDxt3Block(imageReader, x, y, blockCountX, width, height, imageData);
+					}
+                }
+            }
+
+            return imageData;
+        }
+
+        private static void DecompressDxt3Block(BinaryReader imageReader, int x, int y, int blockCountX, int width, int height, byte[] imageData)
+        {
+            byte a0 = imageReader.ReadByte();
+			byte a1 = imageReader.ReadByte();
+			byte a2 = imageReader.ReadByte();
+			byte a3 = imageReader.ReadByte();
+			byte a4 = imageReader.ReadByte();
+			byte a5 = imageReader.ReadByte();
+			byte a6 = imageReader.ReadByte();
+			byte a7 = imageReader.ReadByte();
+            
+            ushort c0 = imageReader.ReadUInt16();
+            ushort c1 = imageReader.ReadUInt16();
+
+			byte r0, g0, b0;
+			byte r1, g1, b1;
+			ConvertRgb565ToRgb888(c0, out r0, out g0, out b0);
+			ConvertRgb565ToRgb888(c1, out r1, out g1, out b1);
+
+            uint lookupTable = imageReader.ReadUInt32();
+
+			int alphaIndex = 0;
+            for (int blockY = 0; blockY < 4; blockY++)
+            {
+                for (int blockX = 0; blockX < 4; blockX++)
+                {
+					byte r = 0, g = 0, b = 0, a = 0;
+
+                    uint index = (lookupTable >> 2 * (4 * blockY + blockX)) & 0x03;
+					
+					switch (alphaIndex)
+					{
+						case 0:
+							a = (byte)((a0 & 0x0F) | ((a0 & 0x0F) << 4));
+							break;
+						case 1:
+							a = (byte)((a0 & 0xF0) | ((a0 & 0xF0) >> 4));
+							break;
+						case 2:
+							a = (byte)((a1 & 0x0F) | ((a1 & 0x0F) << 4));
+							break;
+						case 3:
+							a = (byte)((a1 & 0xF0) | ((a1 & 0xF0) >> 4));
+							break;
+						case 4:
+							a = (byte)((a2 & 0x0F) | ((a2 & 0x0F) << 4));
+							break;
+						case 5:
+							a = (byte)((a2 & 0xF0) | ((a2 & 0xF0) >> 4));
+							break;
+						case 6:
+							a = (byte)((a3 & 0x0F) | ((a3 & 0x0F) << 4));
+							break;
+						case 7:
+							a = (byte)((a3 & 0xF0) | ((a3 & 0xF0) >> 4));
+							break;
+						case 8:
+							a = (byte)((a4 & 0x0F) | ((a4 & 0x0F) << 4));
+							break;
+						case 9:
+							a = (byte)((a4 & 0xF0) | ((a4 & 0xF0) >> 4));
+							break;
+						case 10:
+							a = (byte)((a5 & 0x0F) | ((a5 & 0x0F) << 4));
+							break;
+						case 11:
+							a = (byte)((a5 & 0xF0) | ((a5 & 0xF0) >> 4));
+							break;
+						case 12:
+							a = (byte)((a6 & 0x0F) | ((a6 & 0x0F) << 4));
+							break;
+						case 13:
+							a = (byte)((a6 & 0xF0) | ((a6 & 0xF0) >> 4));
+							break;
+						case 14:
+							a = (byte)((a7 & 0x0F) | ((a7 & 0x0F) << 4));
+							break;
+						case 15:
+							a = (byte)((a7 & 0xF0) | ((a7 & 0xF0) >> 4));
+							break;
+					}
+					++alphaIndex;
+
+                    switch (index)
+                    {
+						case 0:
+							r = r0;
+							g = g0;
+							b = b0;
+							break;
+						case 1:
+							r = r1;
+							g = g1;
+							b = b1;
+							break;
+						case 2:
+							r = (byte)((2 * r0 + r1) / 3);
+							g = (byte)((2 * g0 + g1) / 3);
+							b = (byte)((2 * b0 + b1) / 3);
+							break;
+						case 3:
+							r = (byte)((r0 + 2 * r1) / 3);
+							g = (byte)((g0 + 2 * g1) / 3);
+							b = (byte)((b0 + 2 * b1) / 3);
+							break;
+					}
+
+					int px = (x << 2) + blockX;
+					int py = (y << 2) + blockY;
+					if ((px < width) && (py < height))
+					{
+						int offset = ((py * width) + px) << 2;
+						imageData[offset] = r;
+						imageData[offset + 1] = g;
+						imageData[offset + 2] = b;
+						imageData[offset + 3] = a;
+					}
+				}
+            }
+        }
+		
+        internal static byte[] DecompressDxt5(byte[] imageData, int width, int height)
+        {
+            using (MemoryStream imageStream = new MemoryStream(imageData))
+                return DecompressDxt5(imageStream, width, height);
+        }
+        
+        internal static byte[] DecompressDxt5(Stream imageStream, int width, int height)
+		{
+            byte[] imageData = new byte[width * height * 4];
+
+            using (BinaryReader imageReader = new BinaryReader(imageStream))
+            {
+                int blockCountX = (width + 3) / 4;
+                int blockCountY = (height + 3) / 4;
+                
+                for (int y = 0; y < blockCountY; y++)
+                {
+                    for (int x = 0; x < blockCountX; x++)
+                    {
+                        DecompressDxt5Block(imageReader, x, y, blockCountX, width, height, imageData);
+                    }
+                }
+            }
+
+            return imageData;
+        }
+
+        private static void DecompressDxt5Block(BinaryReader imageReader, int x, int y, int blockCountX, int width, int height, byte[] imageData)
+        {
+            byte alpha0 = imageReader.ReadByte();
+            byte alpha1 = imageReader.ReadByte();
+
+            ulong alphaMask = (ulong)imageReader.ReadByte();
+            alphaMask += (ulong)imageReader.ReadByte() << 8;
+            alphaMask += (ulong)imageReader.ReadByte() << 16;
+            alphaMask += (ulong)imageReader.ReadByte() << 24;
+            alphaMask += (ulong)imageReader.ReadByte() << 32;
+            alphaMask += (ulong)imageReader.ReadByte() << 40;
+
+            ushort c0 = imageReader.ReadUInt16();
+            ushort c1 = imageReader.ReadUInt16();
+
+			byte r0, g0, b0;
+			byte r1, g1, b1;
+			ConvertRgb565ToRgb888(c0, out r0, out g0, out b0);
+			ConvertRgb565ToRgb888(c1, out r1, out g1, out b1);
+
+            uint lookupTable = imageReader.ReadUInt32();
+
+            for (int blockY = 0; blockY < 4; blockY++)
+            {
+                for (int blockX = 0; blockX < 4; blockX++)
+                {
+					byte r = 0, g = 0, b = 0, a = 255;
+                    uint index = (lookupTable >> 2 * (4 * blockY + blockX)) & 0x03;
+                    
+                    uint alphaIndex = (uint)((alphaMask >> 3 * (4 * blockY + blockX)) & 0x07);
+                    if (alphaIndex == 0)
+					{
+                        a = alpha0;
+                    }
+					else if (alphaIndex == 1)
+					{
+                        a = alpha1;
+                    }
+					else if (alpha0 > alpha1)
+					{
+                        a = (byte)(((8 - alphaIndex) * alpha0 + (alphaIndex - 1) * alpha1) / 7);
+                    }
+					else if (alphaIndex == 6)
+					{
+                        a = 0;
+                    }
+					else if (alphaIndex == 7)
+					{
+                        a = 0xff;
+                    }
+					else
+					{
+                        a = (byte)(((6 - alphaIndex) * alpha0 + (alphaIndex - 1) * alpha1) / 5);
+                    }
+
+					switch (index)
+					{
+						case 0:
+							r = r0;
+							g = g0;
+							b = b0;
+							break;
+						case 1:
+							r = r1;
+							g = g1;
+							b = b1;
+							break;
+						case 2:
+							r = (byte)((2 * r0 + r1) / 3);
+							g = (byte)((2 * g0 + g1) / 3);
+							b = (byte)((2 * b0 + b1) / 3);
+							break;
+						case 3:
+							r = (byte)((r0 + 2 * r1) / 3);
+							g = (byte)((g0 + 2 * g1) / 3);
+							b = (byte)((b0 + 2 * b1) / 3);
+							break;
+					}
+
+					int px = (x << 2) + blockX;
+					int py = (y << 2) + blockY;
+					if ((px < width) && (py < height))
+					{
+						int offset = ((py * width) + px) << 2;
+						imageData[offset] = r;
+						imageData[offset + 1] = g;
+						imageData[offset + 2] = b;
+						imageData[offset + 3] = a;
+					}
+				}
+            }
+        }
+        		
+		private static void ConvertRgb565ToRgb888(ushort color, out byte r, out byte g, out byte b)
+		{
+			int temp;
+
+			temp = (color >> 11) * 255 + 16;
+			r = (byte)((temp / 32 + temp) / 32);
+			temp = ((color & 0x07E0) >> 5) * 255 + 32;
+			g = (byte)((temp / 64 + temp) / 64);
+			temp = (color & 0x001F) * 255 + 16;
+			b = (byte)((temp / 32 + temp) / 32);
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Effect/AlphaTestEffect.cs b/MonoGame.Framework/Graphics/Effect/AlphaTestEffect.cs
new file mode 100644
index 00000000000..cc8f560df83
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/AlphaTestEffect.cs
@@ -0,0 +1,441 @@
+#region File Description
+//-----------------------------------------------------------------------------
+// AlphaTestEffect.cs
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+#endregion
+
+#region Using Statements
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+#endregion
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Built-in effect that supports alpha testing.
+    /// </summary>
+    public class AlphaTestEffect : Effect, IEffectMatrices, IEffectFog
+    {
+        #region Effect Parameters
+
+        EffectParameter textureParam;
+        EffectParameter diffuseColorParam;
+        EffectParameter alphaTestParam;
+        EffectParameter fogColorParam;
+        EffectParameter fogVectorParam;
+        EffectParameter worldViewProjParam;
+
+        #endregion
+
+        #region Fields
+
+        bool fogEnabled;
+        bool vertexColorEnabled;
+
+        Matrix world = Matrix.Identity;
+        Matrix view = Matrix.Identity;
+        Matrix projection = Matrix.Identity;
+
+        Matrix worldView;
+
+        Vector3 diffuseColor = Vector3.One;
+
+        float alpha = 1;
+
+        float fogStart = 0;
+        float fogEnd = 1;
+
+        CompareFunction alphaFunction = CompareFunction.Greater;
+        int referenceAlpha;
+        bool isEqNe;
+
+        EffectDirtyFlags dirtyFlags = EffectDirtyFlags.All;
+
+        #endregion
+
+        #region Public Properties
+
+
+        /// <summary>
+        /// Gets or sets the world matrix.
+        /// </summary>
+        public Matrix World
+        {
+            get { return world; }
+            
+            set
+            {
+                world = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj | EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the view matrix.
+        /// </summary>
+        public Matrix View
+        {
+            get { return view; }
+            
+            set
+            {
+                view = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj | EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the projection matrix.
+        /// </summary>
+        public Matrix Projection
+        {
+            get { return projection; }
+            
+            set
+            {
+                projection = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material diffuse color (range 0 to 1).
+        /// </summary>
+        public Vector3 DiffuseColor
+        {
+            get { return diffuseColor; }
+            
+            set
+            {
+                diffuseColor = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material alpha.
+        /// </summary>
+        public float Alpha
+        {
+            get { return alpha; }
+            
+            set
+            {
+                alpha = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog enable flag.
+        /// </summary>
+        public bool FogEnabled
+        {
+            get { return fogEnabled; }
+            
+            set
+            {
+                if (fogEnabled != value)
+                {
+                    fogEnabled = value;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex | EffectDirtyFlags.FogEnable;
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog start distance.
+        /// </summary>
+        public float FogStart
+        {
+            get { return fogStart; }
+            
+            set
+            {
+                fogStart = value;
+                dirtyFlags |= EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog end distance.
+        /// </summary>
+        public float FogEnd
+        {
+            get { return fogEnd; }
+            
+            set
+            {
+                fogEnd = value;
+                dirtyFlags |= EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog color.
+        /// </summary>
+        public Vector3 FogColor
+        {
+            get { return fogColorParam.GetValueVector3(); }
+            set { fogColorParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the current texture.
+        /// </summary>
+        public Texture2D Texture
+        {
+            get { return textureParam.GetValueTexture2D(); }
+            set { textureParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets whether vertex color is enabled.
+        /// </summary>
+        public bool VertexColorEnabled
+        {
+            get { return vertexColorEnabled; }
+            
+            set
+            {
+                if (vertexColorEnabled != value)
+                {
+                    vertexColorEnabled = value;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex;
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the alpha compare function (default Greater).
+        /// </summary>
+        public CompareFunction AlphaFunction
+        {
+            get { return alphaFunction; }
+            
+            set
+            {
+                alphaFunction = value;
+                dirtyFlags |= EffectDirtyFlags.AlphaTest;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the reference alpha value (default 0).
+        /// </summary>
+        public int ReferenceAlpha
+        {
+            get { return referenceAlpha; }
+            
+            set
+            {
+                referenceAlpha = value;
+                dirtyFlags |= EffectDirtyFlags.AlphaTest;
+            }
+        }
+
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Creates a new AlphaTestEffect with default parameter settings.
+        /// </summary>
+        public AlphaTestEffect(GraphicsDevice device)
+            : base(device, EffectResource.AlphaTestEffect.Bytecode)
+        {
+            CacheEffectParameters();
+        }
+
+        /// <summary>
+        /// Creates a new AlphaTestEffect by cloning parameter settings from an existing instance.
+        /// </summary>
+        protected AlphaTestEffect(AlphaTestEffect cloneSource)
+            : base(cloneSource)
+        {
+            CacheEffectParameters();
+
+            fogEnabled = cloneSource.fogEnabled;
+            vertexColorEnabled = cloneSource.vertexColorEnabled;
+
+            world = cloneSource.world;
+            view = cloneSource.view;
+            projection = cloneSource.projection;
+
+            diffuseColor = cloneSource.diffuseColor;
+
+            alpha = cloneSource.alpha;
+
+            fogStart = cloneSource.fogStart;
+            fogEnd = cloneSource.fogEnd;
+            
+            alphaFunction = cloneSource.alphaFunction;
+            referenceAlpha = cloneSource.referenceAlpha;
+
+        }
+
+        /// <summary>
+        /// Creates a clone of the current AlphaTestEffect instance.
+        /// </summary>
+        public override Effect Clone()
+        {
+            return new AlphaTestEffect(this);
+        }
+
+        /// <summary>
+        /// Looks up shortcut references to our effect parameters.
+        /// </summary>
+        void CacheEffectParameters()
+        {
+            textureParam        = Parameters["Texture"];
+            diffuseColorParam   = Parameters["DiffuseColor"];
+            alphaTestParam      = Parameters["AlphaTest"];
+            fogColorParam       = Parameters["FogColor"];
+            fogVectorParam      = Parameters["FogVector"];
+            worldViewProjParam  = Parameters["WorldViewProj"];
+        }
+        
+        /// <summary>
+        /// Lazily computes derived parameter values immediately before applying the effect.
+        /// </summary>
+        protected internal override void OnApply()
+        {
+            // Recompute the world+view+projection matrix or fog vector?
+            dirtyFlags = EffectHelpers.SetWorldViewProjAndFog(dirtyFlags, ref world, ref view, ref projection, ref worldView, fogEnabled, fogStart, fogEnd, worldViewProjParam, fogVectorParam);
+
+            // Recompute the diffuse/alpha material color parameter?
+            if ((dirtyFlags & EffectDirtyFlags.MaterialColor) != 0)
+            {
+                diffuseColorParam.SetValue(new Vector4(diffuseColor * alpha, alpha));
+
+                dirtyFlags &= ~EffectDirtyFlags.MaterialColor;
+            }
+
+            // Recompute the alpha test settings?
+            if ((dirtyFlags & EffectDirtyFlags.AlphaTest) != 0)
+            {
+                Vector4 alphaTest = new Vector4();
+                bool eqNe = false;
+                
+                // Convert reference alpha from 8 bit integer to 0-1 float format.
+                float reference = (float)referenceAlpha / 255f;
+                
+                // Comparison tolerance of half the 8 bit integer precision.
+                const float threshold = 0.5f / 255f;
+                
+                switch (alphaFunction)
+                {
+                    case CompareFunction.Less:
+                        // Shader will evaluate: clip((a < x) ? z : w)
+                        alphaTest.X = reference - threshold;
+                        alphaTest.Z = 1;
+                        alphaTest.W = -1;
+                        break;
+
+                    case CompareFunction.LessEqual:
+                        // Shader will evaluate: clip((a < x) ? z : w)
+                        alphaTest.X = reference + threshold;
+                        alphaTest.Z = 1;
+                        alphaTest.W = -1;
+                        break;
+
+                    case CompareFunction.GreaterEqual:
+                        // Shader will evaluate: clip((a < x) ? z : w)
+                        alphaTest.X = reference - threshold;
+                        alphaTest.Z = -1;
+                        alphaTest.W = 1;
+                        break;
+
+                    case CompareFunction.Greater:
+                        // Shader will evaluate: clip((a < x) ? z : w)
+                        alphaTest.X = reference + threshold;
+                        alphaTest.Z = -1;
+                        alphaTest.W = 1;
+                        break;
+
+                    case CompareFunction.Equal:
+                        // Shader will evaluate: clip((abs(a - x) < Y) ? z : w)
+                        alphaTest.X = reference;
+                        alphaTest.Y = threshold;
+                        alphaTest.Z = 1;
+                        alphaTest.W = -1;
+                        eqNe = true;
+                        break;
+
+                    case CompareFunction.NotEqual:
+                        // Shader will evaluate: clip((abs(a - x) < Y) ? z : w)
+                        alphaTest.X = reference;
+                        alphaTest.Y = threshold;
+                        alphaTest.Z = -1;
+                        alphaTest.W = 1;
+                        eqNe = true;
+                        break;
+
+                    case CompareFunction.Never:
+                        // Shader will evaluate: clip((a < x) ? z : w)
+                        alphaTest.Z = -1;
+                        alphaTest.W = -1;
+                        break;
+
+                    case CompareFunction.Always:
+                    default:
+                        // Shader will evaluate: clip((a < x) ? z : w)
+                        alphaTest.Z = 1;
+                        alphaTest.W = 1;
+                        break;
+                }
+                
+                alphaTestParam.SetValue(alphaTest);
+
+                dirtyFlags &= ~EffectDirtyFlags.AlphaTest;
+                
+                // If we changed between less/greater vs. equal/notequal
+                // compare modes, we must also update the shader index.
+                if (isEqNe != eqNe)
+                {
+                    isEqNe = eqNe;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex;
+                }
+            }
+
+            // Recompute the shader index?
+            if ((dirtyFlags & EffectDirtyFlags.ShaderIndex) != 0)
+            {
+                int shaderIndex = 0;
+                
+                if (!fogEnabled)
+                    shaderIndex += 1;
+                
+                if (vertexColorEnabled)
+                    shaderIndex += 2;
+                
+                if (isEqNe)
+                    shaderIndex += 4;
+
+                dirtyFlags &= ~EffectDirtyFlags.ShaderIndex;
+
+                CurrentTechnique = Techniques[shaderIndex];
+            }
+        }
+
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Effect/BasicEffect.cs b/MonoGame.Framework/Graphics/Effect/BasicEffect.cs
new file mode 100644
index 00000000000..6da7ff1d7e0
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/BasicEffect.cs
@@ -0,0 +1,501 @@
+#region File Description
+//-----------------------------------------------------------------------------
+// BasicEffect.cs
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+#endregion
+
+#region Using Statements
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+#endregion
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Built-in effect that supports optional texturing, vertex coloring, fog, and lighting.
+    /// </summary>
+    public class BasicEffect : Effect, IEffectMatrices, IEffectLights, IEffectFog
+    {
+        #region Effect Parameters
+
+        EffectParameter textureParam;
+        EffectParameter diffuseColorParam;
+        EffectParameter emissiveColorParam;
+        EffectParameter specularColorParam;
+        EffectParameter specularPowerParam;
+        EffectParameter eyePositionParam;
+        EffectParameter fogColorParam;
+        EffectParameter fogVectorParam;
+        EffectParameter worldParam;
+        EffectParameter worldInverseTransposeParam;
+        EffectParameter worldViewProjParam;
+
+        #endregion
+
+        #region Fields
+
+        bool lightingEnabled;
+        bool preferPerPixelLighting;
+        bool oneLight;
+        bool fogEnabled;
+        bool textureEnabled;
+        bool vertexColorEnabled;
+
+        Matrix world = Matrix.Identity;
+        Matrix view = Matrix.Identity;
+        Matrix projection = Matrix.Identity;
+
+        Matrix worldView;
+
+        Vector3 diffuseColor = Vector3.One;
+        Vector3 emissiveColor = Vector3.Zero;
+        Vector3 ambientLightColor = Vector3.Zero;
+
+        float alpha = 1;
+
+        DirectionalLight light0;
+        DirectionalLight light1;
+        DirectionalLight light2;
+
+        float fogStart = 0;
+        float fogEnd = 1;
+
+        EffectDirtyFlags dirtyFlags = EffectDirtyFlags.All;
+
+        #endregion
+        
+        #region Public Properties
+
+
+        /// <summary>
+        /// Gets or sets the world matrix.
+        /// </summary>
+        public Matrix World
+        {
+            get { return world; }
+            
+            set
+            {
+                world = value;
+                dirtyFlags |= EffectDirtyFlags.World | EffectDirtyFlags.WorldViewProj | EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the view matrix.
+        /// </summary>
+        public Matrix View
+        {
+            get { return view; }
+            
+            set
+            {
+                view = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj | EffectDirtyFlags.EyePosition | EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the projection matrix.
+        /// </summary>
+        public Matrix Projection
+        {
+            get { return projection; }
+            
+            set
+            {
+                projection = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material diffuse color (range 0 to 1).
+        /// </summary>
+        public Vector3 DiffuseColor
+        {
+            get { return diffuseColor; }
+            
+            set
+            {
+                diffuseColor = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material emissive color (range 0 to 1).
+        /// </summary>
+        public Vector3 EmissiveColor
+        {
+            get { return emissiveColor; }
+            
+            set
+            {
+                emissiveColor = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material specular color (range 0 to 1).
+        /// </summary>
+        public Vector3 SpecularColor
+        {
+            get { return specularColorParam.GetValueVector3(); }
+            set { specularColorParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material specular power.
+        /// </summary>
+        public float SpecularPower
+        {
+            get { return specularPowerParam.GetValueSingle(); }
+            set { specularPowerParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material alpha.
+        /// </summary>
+        public float Alpha
+        {
+            get { return alpha; }
+            
+            set
+            {
+                alpha = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+        /// <inheritdoc/>
+        public bool LightingEnabled
+        {
+            get { return lightingEnabled; }
+            
+            set
+            {
+                if (lightingEnabled != value)
+                {
+                    lightingEnabled = value;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex | EffectDirtyFlags.MaterialColor;
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the per-pixel lighting prefer flag.
+        /// </summary>
+        public bool PreferPerPixelLighting
+        {
+            get { return preferPerPixelLighting; }
+            
+            set
+            {
+                if (preferPerPixelLighting != value)
+                {
+                    preferPerPixelLighting = value;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex;
+                }
+            }
+        }
+
+
+        /// <inheritdoc/>
+        public Vector3 AmbientLightColor
+        {
+            get { return ambientLightColor; }
+            
+            set
+            {
+                ambientLightColor = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <inheritdoc/>
+        public DirectionalLight DirectionalLight0 { get { return light0; } }
+
+
+        /// <inheritdoc/>
+        public DirectionalLight DirectionalLight1 { get { return light1; } }
+
+
+        /// <inheritdoc/>
+        public DirectionalLight DirectionalLight2 { get { return light2; } }
+
+
+        /// <inheritdoc/>
+        public bool FogEnabled
+        {
+            get { return fogEnabled; }
+            
+            set
+            {
+                if (fogEnabled != value)
+                {
+                    fogEnabled = value;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex | EffectDirtyFlags.FogEnable;
+                }
+            }
+        }
+
+
+        /// <inheritdoc/>
+        public float FogStart
+        {
+            get { return fogStart; }
+            
+            set
+            {
+                fogStart = value;
+                dirtyFlags |= EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <inheritdoc/>
+        public float FogEnd
+        {
+            get { return fogEnd; }
+            
+            set
+            {
+                fogEnd = value;
+                dirtyFlags |= EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <inheritdoc/>
+        public Vector3 FogColor
+        {
+            get { return fogColorParam.GetValueVector3(); }
+            set { fogColorParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets whether texturing is enabled.
+        /// </summary>
+        public bool TextureEnabled
+        {
+            get { return textureEnabled; }
+            
+            set
+            {
+                if (textureEnabled != value)
+                {
+                    textureEnabled = value;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex;
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the current texture.
+        /// </summary>
+        public Texture2D Texture
+        {
+            get { return textureParam.GetValueTexture2D(); }
+            set { textureParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets whether vertex color is enabled.
+        /// </summary>
+        public bool VertexColorEnabled
+        {
+            get { return vertexColorEnabled; }
+            
+            set
+            {
+                if (vertexColorEnabled != value)
+                {
+                    vertexColorEnabled = value;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex;
+                }
+            }
+        }
+
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Creates a new BasicEffect with default parameter settings.
+        /// </summary>
+        public BasicEffect(GraphicsDevice device)
+            : base(device, EffectResource.BasicEffect.Bytecode)
+        {
+            CacheEffectParameters(null);
+
+            DirectionalLight0.Enabled = true;
+            SpecularColor = Vector3.One;
+            SpecularPower = 16;
+        }
+
+        /// <summary>
+        /// Creates a new BasicEffect by cloning parameter settings from an existing instance.
+        /// </summary>
+        protected BasicEffect(BasicEffect cloneSource)
+            : base(cloneSource)
+        {
+            CacheEffectParameters(cloneSource);
+
+            lightingEnabled = cloneSource.lightingEnabled;
+            preferPerPixelLighting = cloneSource.preferPerPixelLighting;
+            fogEnabled = cloneSource.fogEnabled;            
+            textureEnabled = cloneSource.textureEnabled;
+            vertexColorEnabled = cloneSource.vertexColorEnabled;
+
+            world = cloneSource.world;
+            view = cloneSource.view;
+            projection = cloneSource.projection;
+
+            diffuseColor = cloneSource.diffuseColor;
+            emissiveColor = cloneSource.emissiveColor;
+            ambientLightColor = cloneSource.ambientLightColor;
+
+            alpha = cloneSource.alpha;
+
+            fogStart = cloneSource.fogStart;
+            fogEnd = cloneSource.fogEnd;
+        }
+
+
+        /// <summary>
+        /// Creates a clone of the current BasicEffect instance.
+        /// </summary>
+        public override Effect Clone()
+        {
+            return new BasicEffect(this);
+        }
+
+
+        /// <inheritdoc/>
+        public void EnableDefaultLighting()
+        {
+            LightingEnabled = true;
+
+            AmbientLightColor = EffectHelpers.EnableDefaultLighting(light0, light1, light2);
+        }
+
+
+        /// <summary>
+        /// Looks up shortcut references to our effect parameters.
+        /// </summary>
+        void CacheEffectParameters(BasicEffect cloneSource)
+        {
+            textureParam                = Parameters["Texture"];
+            diffuseColorParam           = Parameters["DiffuseColor"];
+            emissiveColorParam          = Parameters["EmissiveColor"];
+            specularColorParam          = Parameters["SpecularColor"];
+            specularPowerParam          = Parameters["SpecularPower"];
+            eyePositionParam            = Parameters["EyePosition"];
+            fogColorParam               = Parameters["FogColor"];
+            fogVectorParam              = Parameters["FogVector"];
+            worldParam                  = Parameters["World"];
+            worldInverseTransposeParam  = Parameters["WorldInverseTranspose"];
+            worldViewProjParam          = Parameters["WorldViewProj"];
+
+            light0 = new DirectionalLight(Parameters["DirLight0Direction"],
+                                          Parameters["DirLight0DiffuseColor"],
+                                          Parameters["DirLight0SpecularColor"],
+                                          (cloneSource != null) ? cloneSource.light0 : null);
+
+            light1 = new DirectionalLight(Parameters["DirLight1Direction"],
+                                          Parameters["DirLight1DiffuseColor"],
+                                          Parameters["DirLight1SpecularColor"],
+                                          (cloneSource != null) ? cloneSource.light1 : null);
+
+            light2 = new DirectionalLight(Parameters["DirLight2Direction"],
+                                          Parameters["DirLight2DiffuseColor"],
+                                          Parameters["DirLight2SpecularColor"],
+                                          (cloneSource != null) ? cloneSource.light2 : null);
+        }
+
+
+        /// <summary>
+        /// Lazily computes derived parameter values immediately before applying the effect.
+        /// </summary>
+        protected internal override void OnApply()
+        {
+            // Recompute the world+view+projection matrix or fog vector?
+            dirtyFlags = EffectHelpers.SetWorldViewProjAndFog(dirtyFlags, ref world, ref view, ref projection, ref worldView, fogEnabled, fogStart, fogEnd, worldViewProjParam, fogVectorParam);
+            
+            // Recompute the diffuse/emissive/alpha material color parameters?
+            if ((dirtyFlags & EffectDirtyFlags.MaterialColor) != 0)
+            {
+                EffectHelpers.SetMaterialColor(lightingEnabled, alpha, ref diffuseColor, ref emissiveColor, ref ambientLightColor, diffuseColorParam, emissiveColorParam);
+
+                dirtyFlags &= ~EffectDirtyFlags.MaterialColor;
+            }
+
+            if (lightingEnabled)
+            {
+                // Recompute the world inverse transpose and eye position?
+                dirtyFlags = EffectHelpers.SetLightingMatrices(dirtyFlags, ref world, ref view, worldParam, worldInverseTransposeParam, eyePositionParam);
+
+                
+                // Check if we can use the only-bother-with-the-first-light shader optimization.
+                bool newOneLight = !light1.Enabled && !light2.Enabled;
+                
+                if (oneLight != newOneLight)
+                {
+                    oneLight = newOneLight;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex;
+                }
+            }
+
+            // Recompute the shader index?
+            if ((dirtyFlags & EffectDirtyFlags.ShaderIndex) != 0)
+            {
+                int shaderIndex = 0;
+                
+                if (!fogEnabled)
+                    shaderIndex += 1;
+                
+                if (vertexColorEnabled)
+                    shaderIndex += 2;
+                
+                if (textureEnabled)
+                    shaderIndex += 4;
+
+                if (lightingEnabled)
+                {
+                    if (preferPerPixelLighting)
+                        shaderIndex += 24;
+                    else if (oneLight)
+                        shaderIndex += 16;
+                    else
+                        shaderIndex += 8;
+                }
+
+                dirtyFlags &= ~EffectDirtyFlags.ShaderIndex;
+
+                CurrentTechnique = Techniques[shaderIndex];
+            }
+        }
+
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Effect/DualTextureEffect.cs b/MonoGame.Framework/Graphics/Effect/DualTextureEffect.cs
new file mode 100644
index 00000000000..b64a3280bda
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/DualTextureEffect.cs
@@ -0,0 +1,327 @@
+#region File Description
+//-----------------------------------------------------------------------------
+// DualTextureEffect.cs
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+#endregion
+
+#region Using Statements
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+#endregion
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Built-in effect that supports two-layer multitexturing.
+    /// </summary>
+    public class DualTextureEffect : Effect, IEffectMatrices, IEffectFog
+    {
+        #region Effect Parameters
+
+        EffectParameter textureParam;
+        EffectParameter texture2Param;
+        EffectParameter diffuseColorParam;
+        EffectParameter fogColorParam;
+        EffectParameter fogVectorParam;
+        EffectParameter worldViewProjParam;
+
+        #endregion
+
+        #region Fields
+
+        bool fogEnabled;
+        bool vertexColorEnabled;
+
+        Matrix world = Matrix.Identity;
+        Matrix view = Matrix.Identity;
+        Matrix projection = Matrix.Identity;
+
+        Matrix worldView;
+
+        Vector3 diffuseColor = Vector3.One;
+
+        float alpha = 1;
+
+        float fogStart = 0;
+        float fogEnd = 1;
+
+        EffectDirtyFlags dirtyFlags = EffectDirtyFlags.All;
+
+        #endregion
+
+        #region Public Properties
+
+
+        /// <summary>
+        /// Gets or sets the world matrix.
+        /// </summary>
+        public Matrix World
+        {
+            get { return world; }
+            
+            set
+            {
+                world = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj | EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the view matrix.
+        /// </summary>
+        public Matrix View
+        {
+            get { return view; }
+            
+            set
+            {
+                view = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj | EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the projection matrix.
+        /// </summary>
+        public Matrix Projection
+        {
+            get { return projection; }
+            
+            set
+            {
+                projection = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material diffuse color (range 0 to 1).
+        /// </summary>
+        public Vector3 DiffuseColor
+        {
+            get { return diffuseColor; }
+            
+            set
+            {
+                diffuseColor = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material alpha.
+        /// </summary>
+        public float Alpha
+        {
+            get { return alpha; }
+            
+            set
+            {
+                alpha = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog enable flag.
+        /// </summary>
+        public bool FogEnabled
+        {
+            get { return fogEnabled; }
+            
+            set
+            {
+                if (fogEnabled != value)
+                {
+                    fogEnabled = value;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex | EffectDirtyFlags.FogEnable;
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog start distance.
+        /// </summary>
+        public float FogStart
+        {
+            get { return fogStart; }
+            
+            set
+            {
+                fogStart = value;
+                dirtyFlags |= EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog end distance.
+        /// </summary>
+        public float FogEnd
+        {
+            get { return fogEnd; }
+            
+            set
+            {
+                fogEnd = value;
+                dirtyFlags |= EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog color.
+        /// </summary>
+        public Vector3 FogColor
+        {
+            get { return fogColorParam.GetValueVector3(); }
+            set { fogColorParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the current base texture.
+        /// </summary>
+        public Texture2D Texture
+        {
+            get { return textureParam.GetValueTexture2D(); }
+            set { textureParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the current overlay texture.
+        /// </summary>
+        public Texture2D Texture2
+        {
+            get { return texture2Param.GetValueTexture2D(); }
+            set { texture2Param.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets whether vertex color is enabled.
+        /// </summary>
+        public bool VertexColorEnabled
+        {
+            get { return vertexColorEnabled; }
+            
+            set
+            {
+                if (vertexColorEnabled != value)
+                {
+                    vertexColorEnabled = value;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex;
+                }
+            }
+        }
+
+
+        #endregion
+
+        #region Methods
+
+
+        /// <summary>
+        /// Creates a new DualTextureEffect with default parameter settings.
+        /// </summary>
+        public DualTextureEffect(GraphicsDevice device)
+            : base(device, EffectResource.DualTextureEffect.Bytecode)
+        {
+            CacheEffectParameters();
+        }
+
+
+        /// <summary>
+        /// Creates a new DualTextureEffect by cloning parameter settings from an existing instance.
+        /// </summary>
+        protected DualTextureEffect(DualTextureEffect cloneSource)
+            : base(cloneSource)
+        {
+            CacheEffectParameters();
+
+            fogEnabled = cloneSource.fogEnabled;
+            vertexColorEnabled = cloneSource.vertexColorEnabled;
+
+            world = cloneSource.world;
+            view = cloneSource.view;
+            projection = cloneSource.projection;
+
+            diffuseColor = cloneSource.diffuseColor;
+
+            alpha = cloneSource.alpha;
+
+            fogStart = cloneSource.fogStart;
+            fogEnd = cloneSource.fogEnd;
+        }
+
+
+        /// <summary>
+        /// Creates a clone of the current DualTextureEffect instance.
+        /// </summary>
+        public override Effect Clone()
+        {
+            return new DualTextureEffect(this);
+        }
+
+
+        /// <summary>
+        /// Looks up shortcut references to our effect parameters.
+        /// </summary>
+        void CacheEffectParameters()
+        {
+            textureParam        = Parameters["Texture"];
+            texture2Param       = Parameters["Texture2"];
+            diffuseColorParam   = Parameters["DiffuseColor"];
+            fogColorParam       = Parameters["FogColor"];
+            fogVectorParam      = Parameters["FogVector"];
+            worldViewProjParam  = Parameters["WorldViewProj"];
+        }
+
+
+        /// <summary>
+        /// Lazily computes derived parameter values immediately before applying the effect.
+        /// </summary>
+        protected internal override void OnApply()
+        {
+            // Recompute the world+view+projection matrix or fog vector?
+            dirtyFlags = EffectHelpers.SetWorldViewProjAndFog(dirtyFlags, ref world, ref view, ref projection, ref worldView, fogEnabled, fogStart, fogEnd, worldViewProjParam, fogVectorParam);
+
+            // Recompute the diffuse/alpha material color parameter?
+            if ((dirtyFlags & EffectDirtyFlags.MaterialColor) != 0)
+            {
+                diffuseColorParam.SetValue(new Vector4(diffuseColor * alpha, alpha));
+
+                dirtyFlags &= ~EffectDirtyFlags.MaterialColor;
+            }
+
+            // Recompute the shader index?
+            if ((dirtyFlags & EffectDirtyFlags.ShaderIndex) != 0)
+            {
+                int shaderIndex = 0;
+                
+                if (!fogEnabled)
+                    shaderIndex += 1;
+                
+                if (vertexColorEnabled)
+                    shaderIndex += 2;
+                
+                dirtyFlags &= ~EffectDirtyFlags.ShaderIndex;
+
+                CurrentTechnique = Techniques[shaderIndex];
+            }
+        }
+
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Effect/Effect.cs b/MonoGame.Framework/Graphics/Effect/Effect.cs
new file mode 100644
index 00000000000..a87a4075c5c
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/Effect.cs
@@ -0,0 +1,459 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public class Effect : GraphicsResource
+    {
+        struct MGFXHeader 
+        {
+            /// <summary>
+            /// The MonoGame Effect file format header identifier ("MGFX"). 
+            /// </summary>
+            public static readonly int MGFXSignature = (BitConverter.IsLittleEndian) ? 0x5846474D: 0x4D474658;
+
+            /// <summary>
+            /// The current MonoGame Effect file format versions
+            /// used to detect old packaged content.
+            /// </summary>
+            /// <remarks>
+            /// We should avoid supporting old versions for very long if at all 
+            /// as users should be rebuilding content when packaging their game.
+            /// </remarks>
+            public const int MGFXVersion = 8;
+
+            public int Signature;
+            public int Version;
+            public int Profile;
+            public int EffectKey;
+            public int HeaderSize;
+        }
+
+        public EffectParameterCollection Parameters { get; private set; }
+
+        public EffectTechniqueCollection Techniques { get; private set; }
+
+        public EffectTechnique CurrentTechnique { get; set; }
+  
+        internal ConstantBuffer[] ConstantBuffers { get; private set; }
+
+        private Shader[] _shaders;
+
+	    private readonly bool _isClone;
+
+        internal Effect(GraphicsDevice graphicsDevice)
+		{
+            if (graphicsDevice == null)
+            {
+                throw new ArgumentNullException("graphicsDevice", FrameworkResources.ResourceCreationWhenDeviceIsNull);
+            }
+            this.GraphicsDevice = graphicsDevice;
+		}
+			
+		protected Effect(Effect cloneSource)
+            : this(cloneSource.GraphicsDevice)
+		{
+            _isClone = true;
+            Clone(cloneSource);
+		}
+
+        public Effect(GraphicsDevice graphicsDevice, byte[] effectCode)
+            : this(graphicsDevice, effectCode, 0, effectCode.Length)
+        {
+        }
+
+
+        public Effect (GraphicsDevice graphicsDevice, byte[] effectCode, int index, int count)
+            : this(graphicsDevice)
+		{
+			// By default we currently cache all unique byte streams
+			// and use cloning to populate the effect with parameters,
+			// techniques, and passes.
+			//
+			// This means all the immutable types in an effect:
+			//
+			//  - Shaders
+			//  - Annotations
+			//  - Names
+			//  - State Objects
+			//
+			// Are shared for every instance of an effect while the 
+			// parameter values and constant buffers are copied.
+			//
+			// This might need to change slightly if/when we support
+			// shared constant buffers as 'new' should return unique
+			// effects without any shared instance state.
+ 
+            //Read the header
+            MGFXHeader header = ReadHeader(effectCode, index);
+			var effectKey = header.EffectKey;
+			int headerSize = header.HeaderSize;
+
+            // First look for it in the cache.
+            //
+            Effect cloneSource;
+            if (!graphicsDevice.EffectCache.TryGetValue(effectKey, out cloneSource))
+            {
+                using (var stream = new MemoryStream(effectCode, index + headerSize, count - headerSize, false))
+            	using (var reader = new BinaryReader(stream))
+            {
+                // Create one.
+                cloneSource = new Effect(graphicsDevice);
+                    cloneSource.ReadEffect(reader);
+
+                // Cache the effect for later in its original unmodified state.
+                    graphicsDevice.EffectCache.Add(effectKey, cloneSource);
+                }
+            }
+
+            // Clone it.
+            _isClone = true;
+            Clone(cloneSource);
+        }
+
+        private MGFXHeader ReadHeader(byte[] effectCode, int index)
+        {
+            MGFXHeader header;
+            header.Signature = BitConverter.ToInt32(effectCode, index); index += 4;
+            header.Version = (int)effectCode[index++];
+            header.Profile = (int)effectCode[index++];
+            header.EffectKey = BitConverter.ToInt32(effectCode, index); index += 4;
+            header.HeaderSize = index;
+
+            if (header.Signature != MGFXHeader.MGFXSignature)
+                throw new Exception("This does not appear to be a MonoGame MGFX file!");
+            if (header.Version < MGFXHeader.MGFXVersion)
+                throw new Exception("This MGFX effect is for an older release of MonoGame and needs to be rebuilt.");
+            if (header.Version > MGFXHeader.MGFXVersion)
+                throw new Exception("This MGFX effect seems to be for a newer release of MonoGame.");
+
+            if (header.Profile != Shader.Profile)
+                throw new Exception("This MGFX effect was built for a different platform!");          
+            
+            return header;
+        }
+
+        /// <summary>
+        /// Clone the source into this existing object.
+        /// </summary>
+        /// <remarks>
+        /// Note this is not overloaded in derived classes on purpose.  This is
+        /// only a reason this exists is for caching effects.
+        /// </remarks>
+        /// <param name="cloneSource">The source effect to clone from.</param>
+        private void Clone(Effect cloneSource)
+        {
+            Debug.Assert(_isClone, "Cannot clone into non-cloned effect!");
+
+            // Copy the mutable members of the effect.
+            Parameters = cloneSource.Parameters.Clone();
+            Techniques = cloneSource.Techniques.Clone(this);
+
+            // Make a copy of the immutable constant buffers.
+            ConstantBuffers = new ConstantBuffer[cloneSource.ConstantBuffers.Length];
+            for (var i = 0; i < cloneSource.ConstantBuffers.Length; i++)
+                ConstantBuffers[i] = new ConstantBuffer(cloneSource.ConstantBuffers[i]);
+
+            // Find and set the current technique.
+            for (var i = 0; i < cloneSource.Techniques.Count; i++)
+            {
+                if (cloneSource.Techniques[i] == cloneSource.CurrentTechnique)
+                {
+                    CurrentTechnique = Techniques[i];
+                    break;
+                }
+            }
+
+            // Take a reference to the original shader list.
+            _shaders = cloneSource._shaders;
+        }
+
+        /// <summary>
+        /// Returns a deep copy of the effect where immutable types 
+        /// are shared and mutable data is duplicated.
+        /// </summary>
+        /// <remarks>
+        /// See "Cloning an Effect" in MSDN:
+        /// http://msdn.microsoft.com/en-us/library/windows/desktop/ff476138(v=vs.85).aspx
+        /// </remarks>
+        /// <returns>The cloned effect.</returns>
+		public virtual Effect Clone()
+		{
+            return new Effect(this);
+		}
+
+        protected internal virtual void OnApply()
+        {
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                if (disposing)
+                {
+                    if (!_isClone)
+                    {
+                        // Only the clone source can dispose the shaders.
+                        if (_shaders != null)
+                        {
+                            foreach (var shader in _shaders)
+                                shader.Dispose();
+                        }
+                    }
+
+                    if (ConstantBuffers != null)
+                    {
+                        foreach (var buffer in ConstantBuffers)
+                            buffer.Dispose();
+                        ConstantBuffers = null;
+                    }
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+
+        internal protected override void GraphicsDeviceResetting()
+        {
+            for (var i = 0; i < ConstantBuffers.Length; i++)
+                ConstantBuffers[i].Clear();
+        }
+
+        #region Effect File Reader
+
+		private void ReadEffect (BinaryReader reader)
+		{
+			// TODO: Maybe we should be reading in a string 
+			// table here to save some bytes in the file.
+
+			// Read in all the constant buffers.
+			var buffers = (int)reader.ReadByte ();
+			ConstantBuffers = new ConstantBuffer[buffers];
+			for (var c = 0; c < buffers; c++) 
+            {				
+				var name = reader.ReadString ();               
+
+				// Create the backing system memory buffer.
+				var sizeInBytes = (int)reader.ReadInt16 ();
+
+				// Read the parameter index values.
+				var parameters = new int[reader.ReadByte ()];
+				var offsets = new int[parameters.Length];
+				for (var i = 0; i < parameters.Length; i++) 
+                {
+					parameters [i] = (int)reader.ReadByte ();
+					offsets [i] = (int)reader.ReadUInt16 ();
+				}
+
+                var buffer = new ConstantBuffer(GraphicsDevice,
+				                                sizeInBytes,
+				                                parameters,
+				                                offsets,
+				                                name);
+                ConstantBuffers[c] = buffer;
+            }
+
+            // Read in all the shader objects.
+            var shaders = (int)reader.ReadByte();
+            _shaders = new Shader[shaders];
+            for (var s = 0; s < shaders; s++)
+                _shaders[s] = new Shader(GraphicsDevice, reader);
+
+            // Read in the parameters.
+            Parameters = ReadParameters(reader);
+
+            // Read the techniques.
+            var techniqueCount = (int)reader.ReadByte();
+            var techniques = new EffectTechnique[techniqueCount];
+            for (var t = 0; t < techniqueCount; t++)
+            {
+                var name = reader.ReadString();
+
+                var annotations = ReadAnnotations(reader);
+
+                var passes = ReadPasses(reader, this, _shaders);
+
+                techniques[t] = new EffectTechnique(this, name, passes, annotations);
+            }
+
+            Techniques = new EffectTechniqueCollection(techniques);
+            CurrentTechnique = Techniques[0];
+        }
+
+        private static EffectAnnotationCollection ReadAnnotations(BinaryReader reader)
+        {
+            var count = (int)reader.ReadByte();
+            if (count == 0)
+                return EffectAnnotationCollection.Empty;
+
+            var annotations = new EffectAnnotation[count];
+
+            // TODO: Annotations are not implemented!
+
+            return new EffectAnnotationCollection(annotations);
+        }
+
+        private static EffectPassCollection ReadPasses(BinaryReader reader, Effect effect, Shader[] shaders)
+        {
+            var count = (int)reader.ReadByte();
+            var passes = new EffectPass[count];
+
+            for (var i = 0; i < count; i++)
+            {
+                var name = reader.ReadString();
+                var annotations = ReadAnnotations(reader);
+
+                // Get the vertex shader.
+                Shader vertexShader = null;
+                var shaderIndex = (int)reader.ReadByte();
+                if (shaderIndex != 255)
+                    vertexShader = shaders[shaderIndex];
+
+                // Get the pixel shader.
+                Shader pixelShader = null;
+                shaderIndex = (int)reader.ReadByte();
+                if (shaderIndex != 255)
+                    pixelShader = shaders[shaderIndex];
+
+				BlendState blend = null;
+				DepthStencilState depth = null;
+				RasterizerState raster = null;
+				if (reader.ReadBoolean())
+				{
+					blend = new BlendState
+					{
+						AlphaBlendFunction = (BlendFunction)reader.ReadByte(),
+						AlphaDestinationBlend = (Blend)reader.ReadByte(),
+						AlphaSourceBlend = (Blend)reader.ReadByte(),
+						BlendFactor = new Color(reader.ReadByte(), reader.ReadByte(), reader.ReadByte(), reader.ReadByte()),
+						ColorBlendFunction = (BlendFunction)reader.ReadByte(),
+						ColorDestinationBlend = (Blend)reader.ReadByte(),
+						ColorSourceBlend = (Blend)reader.ReadByte(),
+						ColorWriteChannels = (ColorWriteChannels)reader.ReadByte(),
+						ColorWriteChannels1 = (ColorWriteChannels)reader.ReadByte(),
+						ColorWriteChannels2 = (ColorWriteChannels)reader.ReadByte(),
+						ColorWriteChannels3 = (ColorWriteChannels)reader.ReadByte(),
+						MultiSampleMask = reader.ReadInt32(),
+					};
+				}
+				if (reader.ReadBoolean())
+				{
+					depth = new DepthStencilState
+					{
+						CounterClockwiseStencilDepthBufferFail = (StencilOperation)reader.ReadByte(),
+						CounterClockwiseStencilFail = (StencilOperation)reader.ReadByte(),
+						CounterClockwiseStencilFunction = (CompareFunction)reader.ReadByte(),
+						CounterClockwiseStencilPass = (StencilOperation)reader.ReadByte(),
+						DepthBufferEnable = reader.ReadBoolean(),
+						DepthBufferFunction = (CompareFunction)reader.ReadByte(),
+						DepthBufferWriteEnable = reader.ReadBoolean(),
+						ReferenceStencil = reader.ReadInt32(),
+						StencilDepthBufferFail = (StencilOperation)reader.ReadByte(),
+						StencilEnable = reader.ReadBoolean(),
+						StencilFail = (StencilOperation)reader.ReadByte(),
+						StencilFunction = (CompareFunction)reader.ReadByte(),
+						StencilMask = reader.ReadInt32(),
+						StencilPass = (StencilOperation)reader.ReadByte(),
+						StencilWriteMask = reader.ReadInt32(),
+						TwoSidedStencilMode = reader.ReadBoolean(),
+					};
+				}
+				if (reader.ReadBoolean())
+				{
+					raster = new RasterizerState
+					{
+						CullMode = (CullMode)reader.ReadByte(),
+						DepthBias = reader.ReadSingle(),
+						FillMode = (FillMode)reader.ReadByte(),
+						MultiSampleAntiAlias = reader.ReadBoolean(),
+						ScissorTestEnable = reader.ReadBoolean(),
+						SlopeScaleDepthBias = reader.ReadSingle(),
+					};
+				}
+
+                passes[i] = new EffectPass(effect, name, vertexShader, pixelShader, blend, depth, raster, annotations);
+			}
+
+            return new EffectPassCollection(passes);
+		}
+
+		private static EffectParameterCollection ReadParameters(BinaryReader reader)
+		{
+			var count = (int)reader.ReadByte();			
+            if (count == 0)
+                return EffectParameterCollection.Empty;
+
+            var parameters = new EffectParameter[count];
+			for (var i = 0; i < count; i++)
+			{
+				var class_ = (EffectParameterClass)reader.ReadByte();				
+                var type = (EffectParameterType)reader.ReadByte();
+				var name = reader.ReadString();
+				var semantic = reader.ReadString();
+				var annotations = ReadAnnotations(reader);
+				var rowCount = (int)reader.ReadByte();
+				var columnCount = (int)reader.ReadByte();
+
+				var elements = ReadParameters(reader);
+				var structMembers = ReadParameters(reader);
+
+				object data = null;
+				if (elements.Count == 0 && structMembers.Count == 0)
+				{
+					switch (type)
+					{						
+                        case EffectParameterType.Bool:
+                        case EffectParameterType.Int32:
+#if !OPENGL
+                            // Under most platforms we properly store integers and 
+                            // booleans in an integer type.
+                            //
+                            // MojoShader on the otherhand stores everything in float
+                            // types which is why this code is disabled under OpenGL.
+					        {
+					            var buffer = new int[rowCount * columnCount];								
+                                for (var j = 0; j < buffer.Length; j++)
+                                    buffer[j] = reader.ReadInt32();
+                                data = buffer;
+                                break;
+					        }
+#endif
+
+						case EffectParameterType.Single:
+							{
+								var buffer = new float[rowCount * columnCount];
+								for (var j = 0; j < buffer.Length; j++)
+                                    buffer[j] = reader.ReadSingle();
+                                data = buffer;
+                                break;							
+                            }
+
+                        case EffectParameterType.String:
+                            // TODO: We have not investigated what a string
+                            // type should do in the parameter list.  Till then
+                            // throw to let the user know.
+							throw new NotSupportedException();
+
+                        default:
+                            // NOTE: We skip over all other types as they 
+                            // don't get added to the constant buffer.
+					        break;
+					}
+                }
+
+				parameters[i] = new EffectParameter(
+					class_, type, name, rowCount, columnCount, semantic, 
+					annotations, elements, structMembers, data);
+			}
+
+			return new EffectParameterCollection(parameters);
+		}
+        #endregion // Effect File Reader
+	}
+}
diff --git a/MonoGame.Framework/Graphics/Effect/EffectAnnotation.cs b/MonoGame.Framework/Graphics/Effect/EffectAnnotation.cs
new file mode 100644
index 00000000000..9e41595fa40
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectAnnotation.cs
@@ -0,0 +1,44 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    // TODO: This class needs to be finished!
+
+	public class EffectAnnotation
+	{
+		internal EffectAnnotation (
+			EffectParameterClass class_,
+			EffectParameterType type,
+			string name,
+			int rowCount,
+			int columnCount,
+			string semantic,
+			object data)
+		{
+			ParameterClass = class_;
+			ParameterType = type;
+			Name = name;
+			RowCount = rowCount;
+			ColumnCount = columnCount;
+			Semantic = semantic;
+		}
+
+		internal EffectAnnotation (EffectParameter parameter)
+		{
+			ParameterClass = parameter.ParameterClass;
+			ParameterType = parameter.ParameterType;
+			Name = parameter.Name;
+			RowCount = parameter.RowCount;
+			ColumnCount = parameter.ColumnCount;
+			Semantic = parameter.Semantic;
+		}
+
+		public EffectParameterClass ParameterClass {get; private set;}
+		public EffectParameterType ParameterType {get; private set;}
+		public string Name {get; private set;}
+		public int RowCount {get; private set;}
+		public int ColumnCount {get; private set;}
+		public string Semantic {get; private set;}
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Effect/EffectAnnotationCollection.cs b/MonoGame.Framework/Graphics/Effect/EffectAnnotationCollection.cs
new file mode 100644
index 00000000000..8f8f16a3654
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectAnnotationCollection.cs
@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public class EffectAnnotationCollection : IEnumerable<EffectAnnotation>
+	{
+        internal static readonly EffectAnnotationCollection Empty = new EffectAnnotationCollection(new EffectAnnotation[0]);
+
+	    private readonly EffectAnnotation[] _annotations;
+
+        internal EffectAnnotationCollection(EffectAnnotation[] annotations)
+        {
+            _annotations = annotations;
+        }
+
+		public int Count 
+        {
+			get { return _annotations.Length; }
+		}
+		
+		public EffectAnnotation this[int index]
+        {
+            get { return _annotations[index]; }
+        }
+		
+		public EffectAnnotation this[string name]
+        {
+            get 
+            {
+				foreach (var annotation in _annotations) 
+                {
+					if (annotation.Name == name)
+						return annotation;
+				}
+				return null;
+			}
+        }
+		
+		public IEnumerator<EffectAnnotation> GetEnumerator()
+        {
+            return ((IEnumerable<EffectAnnotation>)_annotations).GetEnumerator();
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return _annotations.GetEnumerator();
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Effect/EffectHelpers.cs b/MonoGame.Framework/Graphics/Effect/EffectHelpers.cs
new file mode 100644
index 00000000000..20edb17f417
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectHelpers.cs
@@ -0,0 +1,241 @@
+//#region File Description
+//-----------------------------------------------------------------------------
+// EffectHelpers.cs
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+//#endregion
+
+//#region Using Statements
+using System;
+//#endregion
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Track which effect parameters need to be recomputed during the next OnApply.
+    /// </summary>
+    [Flags]
+    internal enum EffectDirtyFlags
+    {
+        WorldViewProj   = 1,
+        World           = 2,
+        EyePosition     = 4,
+        MaterialColor   = 8,
+        Fog             = 16,
+        FogEnable       = 32,
+        AlphaTest       = 64,
+        ShaderIndex     = 128,
+        All             = -1
+    }
+
+
+    /// <summary>
+    /// Helper code shared between the various built-in effects.
+    /// </summary>
+    internal static class EffectHelpers
+    {
+        /// <summary>
+        /// Sets up the standard key/fill/back lighting rig.
+        /// </summary>
+        internal static Vector3 EnableDefaultLighting(DirectionalLight light0, DirectionalLight light1, DirectionalLight light2)
+        {
+            // Key light.
+            light0.Direction = new Vector3(-0.5265408f, -0.5735765f, -0.6275069f);
+            light0.DiffuseColor = new Vector3(1, 0.9607844f, 0.8078432f);
+            light0.SpecularColor = new Vector3(1, 0.9607844f, 0.8078432f);
+            light0.Enabled = true;
+
+            // Fill light.
+            light1.Direction = new Vector3(0.7198464f, 0.3420201f, 0.6040227f);
+            light1.DiffuseColor = new Vector3(0.9647059f, 0.7607844f, 0.4078432f);
+            light1.SpecularColor = Vector3.Zero;
+            light1.Enabled = true;
+
+            // Back light.
+            light2.Direction = new Vector3(0.4545195f, -0.7660444f, 0.4545195f);
+            light2.DiffuseColor = new Vector3(0.3231373f, 0.3607844f, 0.3937255f);
+            light2.SpecularColor = new Vector3(0.3231373f, 0.3607844f, 0.3937255f);
+            light2.Enabled = true;
+
+            // Ambient light.
+            return new Vector3(0.05333332f, 0.09882354f, 0.1819608f);
+        }
+
+
+        /// <summary>
+        /// Lazily recomputes the world+view+projection matrix and
+        /// fog vector based on the current effect parameter settings.
+        /// </summary>
+        internal static EffectDirtyFlags SetWorldViewProjAndFog(EffectDirtyFlags dirtyFlags,
+                                                                ref Matrix world, ref Matrix view, ref Matrix projection, ref Matrix worldView,
+                                                                bool fogEnabled, float fogStart, float fogEnd,
+                                                                EffectParameter worldViewProjParam, EffectParameter fogVectorParam)
+        {
+            // Recompute the world+view+projection matrix?
+            if ((dirtyFlags & EffectDirtyFlags.WorldViewProj) != 0)
+            {
+                Matrix worldViewProj;
+                
+                Matrix.Multiply(ref world, ref view, out worldView);
+                Matrix.Multiply(ref worldView, ref projection, out worldViewProj);
+                
+                worldViewProjParam.SetValue(worldViewProj);
+                
+                dirtyFlags &= ~EffectDirtyFlags.WorldViewProj;
+            }
+
+            if (fogEnabled)
+            {
+                // Recompute the fog vector?
+                if ((dirtyFlags & (EffectDirtyFlags.Fog | EffectDirtyFlags.FogEnable)) != 0)
+                {
+                    SetFogVector(ref worldView, fogStart, fogEnd, fogVectorParam);
+
+                    dirtyFlags &= ~(EffectDirtyFlags.Fog | EffectDirtyFlags.FogEnable);
+                }
+            }
+            else
+            {
+                // When fog is disabled, make sure the fog vector is reset to zero.
+                if ((dirtyFlags & EffectDirtyFlags.FogEnable) != 0)
+                {
+                    fogVectorParam.SetValue(Vector4.Zero);
+
+                    dirtyFlags &= ~EffectDirtyFlags.FogEnable;
+                }
+            }
+
+            return dirtyFlags;
+        }
+
+
+        /// <summary>
+        /// Sets a vector which can be dotted with the object space vertex position to compute fog amount.
+        /// </summary>
+        static void SetFogVector(ref Matrix worldView, float fogStart, float fogEnd, EffectParameter fogVectorParam)
+        {
+            if (fogStart == fogEnd)
+            {
+                // Degenerate case: force everything to 100% fogged if start and end are the same.
+                fogVectorParam.SetValue(new Vector4(0, 0, 0, 1));
+            }
+            else
+            {
+                // We want to transform vertex positions into view space, take the resulting
+                // Z value, then scale and offset according to the fog start/end distances.
+                // Because we only care about the Z component, the shader can do all this
+                // with a single dot product, using only the Z row of the world+view matrix.
+                
+                float scale = 1f / (fogStart - fogEnd);
+
+                Vector4 fogVector = new Vector4();
+
+                fogVector.X = worldView.M13 * scale;
+                fogVector.Y = worldView.M23 * scale;
+                fogVector.Z = worldView.M33 * scale;
+                fogVector.W = (worldView.M43 + fogStart) * scale;
+
+                fogVectorParam.SetValue(fogVector);
+            }
+        }
+
+
+        /// <summary>
+        /// Lazily recomputes the world inverse transpose matrix and
+        /// eye position based on the current effect parameter settings.
+        /// </summary>
+        internal static EffectDirtyFlags SetLightingMatrices(EffectDirtyFlags dirtyFlags, ref Matrix world, ref Matrix view,
+                                                             EffectParameter worldParam, EffectParameter worldInverseTransposeParam, EffectParameter eyePositionParam)
+        {
+            // Set the world and world inverse transpose matrices.
+            if ((dirtyFlags & EffectDirtyFlags.World) != 0)
+            {
+                Matrix worldTranspose;
+                Matrix worldInverseTranspose;
+                
+                Matrix.Invert(ref world, out worldTranspose);
+                Matrix.Transpose(ref worldTranspose, out worldInverseTranspose);
+                
+                worldParam.SetValue(world);
+                worldInverseTransposeParam.SetValue(worldInverseTranspose);
+                
+                dirtyFlags &= ~EffectDirtyFlags.World;
+            }
+
+            // Set the eye position.
+            if ((dirtyFlags & EffectDirtyFlags.EyePosition) != 0)
+            {
+                Matrix viewInverse;
+                
+                Matrix.Invert(ref view, out viewInverse);
+
+                eyePositionParam.SetValue(viewInverse.Translation);
+
+                dirtyFlags &= ~EffectDirtyFlags.EyePosition;
+            }
+
+            return dirtyFlags;
+        }
+
+
+        /// <summary>
+        /// Sets the diffuse/emissive/alpha material color parameters.
+        /// </summary>
+        internal static void SetMaterialColor(bool lightingEnabled, float alpha,
+                                              ref Vector3 diffuseColor, ref Vector3 emissiveColor, ref Vector3 ambientLightColor,
+                                              EffectParameter diffuseColorParam, EffectParameter emissiveColorParam)
+        {
+            // Desired lighting model:
+            //
+            //     ((AmbientLightColor + sum(diffuse directional light)) * DiffuseColor) + EmissiveColor
+            //
+            // When lighting is disabled, ambient and directional lights are ignored, leaving:
+            //
+            //     DiffuseColor + EmissiveColor
+            //
+            // For the lighting disabled case, we can save one shader instruction by precomputing
+            // diffuse+emissive on the CPU, after which the shader can use DiffuseColor directly,
+            // ignoring its emissive parameter.
+            //
+            // When lighting is enabled, we can merge the ambient and emissive settings. If we
+            // set our emissive parameter to emissive+(ambient*diffuse), the shader no longer
+            // needs to bother adding the ambient contribution, simplifying its computation to:
+            //
+            //     (sum(diffuse directional light) * DiffuseColor) + EmissiveColor
+            //
+            // For futher optimization goodness, we merge material alpha with the diffuse
+            // color parameter, and premultiply all color values by this alpha.
+            
+            if (lightingEnabled)
+            {
+                Vector4 diffuse = new Vector4();
+                Vector3 emissive = new Vector3();
+                
+                diffuse.X = diffuseColor.X * alpha;
+                diffuse.Y = diffuseColor.Y * alpha;
+                diffuse.Z = diffuseColor.Z * alpha;
+                diffuse.W = alpha;
+
+                emissive.X = (emissiveColor.X + ambientLightColor.X * diffuseColor.X) * alpha;
+                emissive.Y = (emissiveColor.Y + ambientLightColor.Y * diffuseColor.Y) * alpha;
+                emissive.Z = (emissiveColor.Z + ambientLightColor.Z * diffuseColor.Z) * alpha;
+
+                diffuseColorParam.SetValue(diffuse);
+                emissiveColorParam.SetValue(emissive);
+            }
+            else
+            {
+                Vector4 diffuse = new Vector4();
+                
+                diffuse.X = (diffuseColor.X + emissiveColor.X) * alpha;
+                diffuse.Y = (diffuseColor.Y + emissiveColor.Y) * alpha;
+                diffuse.Z = (diffuseColor.Z + emissiveColor.Z) * alpha;
+                diffuse.W = alpha;
+
+                diffuseColorParam.SetValue(diffuse);
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Effect/EffectMaterial.cs b/MonoGame.Framework/Graphics/Effect/EffectMaterial.cs
new file mode 100644
index 00000000000..c01acad463d
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectMaterial.cs
@@ -0,0 +1,51 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+using System;
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public class EffectMaterial : Effect
+	{
+		public EffectMaterial (Effect cloneSource) : base(cloneSource)
+		{
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Effect/EffectParameter.cs b/MonoGame.Framework/Graphics/Effect/EffectParameter.cs
new file mode 100644
index 00000000000..38e8b336209
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectParameter.cs
@@ -0,0 +1,886 @@
+using System;
+using System.Linq;
+using System.Text;
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    [DebuggerDisplay("{DebugDisplayString}")]
+	public class EffectParameter
+	{
+        /// <summary>
+        /// The next state key used when an effect parameter
+        /// is updated by any of the 'set' methods.
+        /// </summary>
+        internal static ulong NextStateKey { get; private set; }
+
+        internal EffectParameter(   EffectParameterClass class_, 
+                                    EffectParameterType type, 
+                                    string name, 
+                                    int rowCount, 
+                                    int columnCount,
+                                    string semantic, 
+                                    EffectAnnotationCollection annotations,
+                                    EffectParameterCollection elements,
+                                    EffectParameterCollection structMembers,
+                                    object data )
+		{
+            ParameterClass = class_;
+            ParameterType = type;
+
+            Name = name;
+            Semantic = semantic;
+            Annotations = annotations;
+
+            RowCount = rowCount;
+			ColumnCount = columnCount;
+
+            Elements = elements;
+            StructureMembers = structMembers;
+
+            Data = data;
+            StateKey = unchecked(NextStateKey++);
+		}
+
+        internal EffectParameter(EffectParameter cloneSource)
+        {
+            // Share all the immutable types.
+            ParameterClass = cloneSource.ParameterClass;
+            ParameterType = cloneSource.ParameterType;
+            Name = cloneSource.Name;
+            Semantic = cloneSource.Semantic;
+            Annotations = cloneSource.Annotations;
+            RowCount = cloneSource.RowCount;
+            ColumnCount = cloneSource.ColumnCount;
+
+            // Clone the mutable types.
+            Elements = cloneSource.Elements.Clone();
+            StructureMembers = cloneSource.StructureMembers.Clone();
+
+            // The data is mutable, so we have to clone it.
+            var array = cloneSource.Data as Array;
+            if (array != null)
+                Data = array.Clone();
+            StateKey = unchecked(NextStateKey++);
+        }
+
+		public string Name { get; private set; }
+
+        public string Semantic { get; private set; }
+
+		public EffectParameterClass ParameterClass { get; private set; }
+
+		public EffectParameterType ParameterType { get; private set; }
+
+		public int RowCount { get; private set; }
+
+        public int ColumnCount { get; private set; }
+
+        public EffectParameterCollection Elements { get; private set; }
+
+        public EffectParameterCollection StructureMembers { get; private set; }
+
+        public EffectAnnotationCollection Annotations { get; private set; }
+
+
+        // TODO: Using object adds alot of boxing/unboxing overhead
+        // and garbage generation.  We should consider a templated
+        // type implementation to fix this!
+
+        internal object Data { get; private set; }
+
+        /// <summary>
+        /// The current state key which is used to detect
+		/// if the parameter value has been changed.
+        /// </summary>
+        internal ulong StateKey { get; private set; }
+
+        /// <summary>
+        /// Property referenced by the DebuggerDisplayAttribute.
+        /// </summary>
+        private string DebugDisplayString
+        {
+            get
+            {
+                var semanticStr = string.Empty;
+                if (!string.IsNullOrEmpty(Semantic))                
+                    semanticStr = string.Concat(" <", Semantic, ">");
+
+                return string.Concat("[", ParameterClass, " ", ParameterType, "]", semanticStr, " ", Name, " : ", GetDataValueString());
+            }
+        }
+
+        private string GetDataValueString()
+        {
+            string valueStr;
+
+            if (Data == null)
+            {
+                if (Elements == null)
+                    valueStr = "(null)";
+                else                
+                    valueStr = string.Join(", ", Elements.Select(e => e.GetDataValueString()));                
+            }
+            else
+            {
+                switch (ParameterClass)
+                {
+                        // Object types are stored directly in the Data property.
+                        // Display Data's string value.
+                    case EffectParameterClass.Object:
+                        valueStr = Data.ToString();
+                        break;
+
+                        // Matrix types are stored in a float[16] which we don't really have room for.
+                        // Display "...".
+                    case EffectParameterClass.Matrix:
+                        valueStr = "...";
+                        break;
+
+                        // Scalar types are stored as a float[1].
+                        // Display the first (and only) element's string value.                    
+                    case EffectParameterClass.Scalar:
+                        valueStr = (Data as Array).GetValue(0).ToString();
+                        break;
+
+                        // Vector types are stored as an Array<Type>.
+                        // Display the string value of each array element.
+                    case EffectParameterClass.Vector:
+                        var array = Data as Array;
+                        var arrayStr = new string[array.Length];
+                        var idx = 0;
+                        foreach (var e in array)
+                        {
+                            arrayStr[idx] = array.GetValue(idx).ToString();
+                            idx++;
+                        }
+
+                        valueStr = string.Join(" ", arrayStr);
+                        break;
+
+                        // Handle additional cases here...
+                    default:
+                        valueStr = Data.ToString();
+                        break;
+                }
+            }
+
+            return string.Concat("{", valueStr, "}");                
+        }
+
+        public bool GetValueBoolean ()
+		{
+            if (ParameterClass != EffectParameterClass.Scalar || ParameterType != EffectParameterType.Bool)
+                throw new InvalidCastException();
+
+#if OPENGL
+            // MojoShader encodes even booleans into a float.
+            return ((float[])Data)[0] != 0.0f;
+#else
+            return ((int[])Data)[0] != 0;
+#endif
+        }
+        
+        /*
+		public bool[] GetValueBooleanArray ()
+		{
+			throw new NotImplementedException();
+		}
+        */
+
+		public int GetValueInt32 ()
+		{
+            if (ParameterClass != EffectParameterClass.Scalar || ParameterType != EffectParameterType.Int32)
+                throw new InvalidCastException();
+
+#if OPENGL
+            // MojoShader encodes integers into a float.
+            return (int)((float[])Data)[0];
+#else
+            return ((int[])Data)[0];
+#endif
+        }
+        
+        /*
+		public int[] GetValueInt32Array ()
+		{
+			throw new NotImplementedException();
+		}
+        */
+
+		public Matrix GetValueMatrix ()
+		{
+            if (ParameterClass != EffectParameterClass.Matrix || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+            if (RowCount != 4 || ColumnCount != 4)
+                throw new InvalidCastException();
+
+            var floatData = (float[])Data;
+
+            return new Matrix(  floatData[0], floatData[4], floatData[8], floatData[12],
+                                floatData[1], floatData[5], floatData[9], floatData[13],
+                                floatData[2], floatData[6], floatData[10], floatData[14],
+                                floatData[3], floatData[7], floatData[11], floatData[15]);
+		}
+        
+		public Matrix[] GetValueMatrixArray (int count)
+		{
+            if (ParameterClass != EffectParameterClass.Matrix || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+            var ret = new Matrix[count];
+            for (var i = 0; i < count; i++)
+                ret[i] = Elements[i].GetValueMatrix();
+
+		    return ret;
+		}
+
+		public Quaternion GetValueQuaternion ()
+		{
+            if (ParameterClass != EffectParameterClass.Vector || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+            var vecInfo = (float[])Data;
+            return new Quaternion(vecInfo[0], vecInfo[1], vecInfo[2], vecInfo[3]);
+        }
+
+        /*
+		public Quaternion[] GetValueQuaternionArray ()
+		{
+			throw new NotImplementedException();
+		}
+        */
+
+		public Single GetValueSingle ()
+		{
+            // TODO: Should this fetch int and bool as a float?
+            if (ParameterClass != EffectParameterClass.Scalar || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+			return ((float[])Data)[0];
+		}
+
+		public Single[] GetValueSingleArray ()
+		{
+			if (Elements != null && Elements.Count > 0)
+            {
+                var ret = new Single[RowCount * ColumnCount * Elements.Count];
+				for (int i=0; i<Elements.Count; i++)
+                {
+                    var elmArray = Elements[i].GetValueSingleArray();
+                    for (var j = 0; j < elmArray.Length; j++)
+						ret[RowCount*ColumnCount*i+j] = elmArray[j];
+				}
+				return ret;
+			}
+			
+			switch(ParameterClass) 
+            {
+			case EffectParameterClass.Scalar:
+				return new Single[] { GetValueSingle () };
+            case EffectParameterClass.Vector:
+			case EffectParameterClass.Matrix:
+                    if (Data is Matrix)
+                        return Matrix.ToFloatArray((Matrix)Data);
+                    else
+                        return (float[])Data;
+			default:
+				throw new NotImplementedException();
+			}
+		}
+
+		public string GetValueString ()
+		{
+            if (ParameterClass != EffectParameterClass.Object || ParameterType != EffectParameterType.String)
+                throw new InvalidCastException();
+
+		    return ((string[])Data)[0];
+		}
+
+		public Texture2D GetValueTexture2D ()
+		{
+            if (ParameterClass != EffectParameterClass.Object || ParameterType != EffectParameterType.Texture2D)
+                throw new InvalidCastException();
+
+			return (Texture2D)Data;
+		}
+
+#if !GLES
+	    public Texture3D GetValueTexture3D ()
+	    {
+            if (ParameterClass != EffectParameterClass.Object || ParameterType != EffectParameterType.Texture3D)
+                throw new InvalidCastException();
+
+            return (Texture3D)Data;
+	    }
+#endif
+
+		public TextureCube GetValueTextureCube ()
+		{
+            if (ParameterClass != EffectParameterClass.Object || ParameterType != EffectParameterType.TextureCube)
+                throw new InvalidCastException();
+
+            return (TextureCube)Data;
+		}
+
+		public Vector2 GetValueVector2 ()
+		{
+            if (ParameterClass != EffectParameterClass.Vector || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+            var vecInfo = (float[])Data;
+			return new Vector2(vecInfo[0],vecInfo[1]);
+		}
+
+		public Vector2[] GetValueVector2Array()
+		{
+            if (ParameterClass != EffectParameterClass.Vector || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+			if (Elements != null && Elements.Count > 0)
+			{
+				Vector2[] result = new Vector2[Elements.Count];
+				for (int i = 0; i < Elements.Count; i++)
+				{
+					var v = Elements[i].GetValueSingleArray();
+					result[i] = new Vector2(v[0], v[1]);
+				}
+			return result;
+			}
+			
+		return null;
+		}
+
+		public Vector3 GetValueVector3 ()
+		{
+            if (ParameterClass != EffectParameterClass.Vector || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+            var vecInfo = (float[])Data;
+			return new Vector3(vecInfo[0],vecInfo[1],vecInfo[2]);
+		}
+
+       public Vector3[] GetValueVector3Array()
+        {
+            if (ParameterClass != EffectParameterClass.Vector || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+            if (Elements != null && Elements.Count > 0)
+            {
+                Vector3[] result = new Vector3[Elements.Count];
+                for (int i = 0; i < Elements.Count; i++)
+                {
+                    var v = Elements[i].GetValueSingleArray();
+                    result[i] = new Vector3(v[0], v[1], v[2]);
+                }
+                return result;
+            }
+            return null;
+        }
+
+
+		public Vector4 GetValueVector4 ()
+		{
+            if (ParameterClass != EffectParameterClass.Vector || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+            var vecInfo = (float[])Data;
+			return new Vector4(vecInfo[0],vecInfo[1],vecInfo[2],vecInfo[3]);
+		}
+        
+          public Vector4[] GetValueVector4Array()
+        {
+            if (ParameterClass != EffectParameterClass.Vector || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+            if (Elements != null && Elements.Count > 0)
+            {
+                Vector4[] result = new Vector4[Elements.Count];
+                for (int i = 0; i < Elements.Count; i++)
+                {
+                    var v = Elements[i].GetValueSingleArray();
+                    result[i] = new Vector4(v[0], v[1],v[2], v[3]);
+                }
+                return result;
+            }
+            return null;
+        }
+
+		public void SetValue (bool value)
+		{
+            if (ParameterClass != EffectParameterClass.Scalar || ParameterType != EffectParameterType.Bool)
+                throw new InvalidCastException();
+
+#if OPENGL
+            // MojoShader encodes even booleans into a float.
+            ((float[])Data)[0] = value ? 1 : 0;
+#else
+            ((int[])Data)[0] = value ? 1 : 0;
+#endif
+
+            StateKey = unchecked(NextStateKey++);
+		}
+
+        /*
+		public void SetValue (bool[] value)
+		{
+			throw new NotImplementedException();
+		}
+        */
+
+		public void SetValue (int value)
+		{
+            if (ParameterClass != EffectParameterClass.Scalar || ParameterType != EffectParameterType.Int32)
+                throw new InvalidCastException();
+
+#if OPENGL
+            // MojoShader encodes integers into a float.
+            ((float[])Data)[0] = value;
+#else
+            ((int[])Data)[0] = value;
+#endif
+            StateKey = unchecked(NextStateKey++);
+		}
+
+        /*
+		public void SetValue (int[] value)
+		{
+			throw new NotImplementedException();
+		}
+        */
+
+        public void SetValue(Matrix value)
+        {
+            if (ParameterClass != EffectParameterClass.Matrix || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+            // HLSL expects matrices to be transposed by default.
+            // These unrolled loops do the transpose during assignment.
+            if (RowCount == 4 && ColumnCount == 4)
+            {
+                var fData = (float[])Data;
+
+                fData[0] = value.M11;
+                fData[1] = value.M21;
+                fData[2] = value.M31;
+                fData[3] = value.M41;
+
+                fData[4] = value.M12;
+                fData[5] = value.M22;
+                fData[6] = value.M32;
+                fData[7] = value.M42;
+
+                fData[8] = value.M13;
+                fData[9] = value.M23;
+                fData[10] = value.M33;
+                fData[11] = value.M43;
+
+                fData[12] = value.M14;
+                fData[13] = value.M24;
+                fData[14] = value.M34;
+                fData[15] = value.M44;
+            }
+            else if (RowCount == 4 && ColumnCount == 3)
+            {
+                var fData = (float[])Data;
+
+                fData[0] = value.M11;
+                fData[1] = value.M21;
+                fData[2] = value.M31;
+                fData[3] = value.M41;
+
+                fData[4] = value.M12;
+                fData[5] = value.M22;
+                fData[6] = value.M32;
+                fData[7] = value.M42;
+
+                fData[8] = value.M13;
+                fData[9] = value.M23;
+                fData[10] = value.M33;
+                fData[11] = value.M43;
+            }
+            else if (RowCount == 3 && ColumnCount == 4)
+            {
+                var fData = (float[])Data;
+
+                fData[0] = value.M11;
+                fData[1] = value.M21;
+                fData[2] = value.M31;
+
+                fData[3] = value.M12;
+                fData[4] = value.M22;
+                fData[5] = value.M32;
+
+                fData[6] = value.M13;
+                fData[7] = value.M23;
+                fData[8] = value.M33;
+
+                fData[9] = value.M14;
+                fData[10] = value.M24;
+                fData[11] = value.M34;
+            }
+            else if (RowCount == 3 && ColumnCount == 3)
+            {
+                var fData = (float[])Data;
+
+                fData[0] = value.M11;
+                fData[1] = value.M21;
+                fData[2] = value.M31;
+
+                fData[3] = value.M12;
+                fData[4] = value.M22;
+                fData[5] = value.M32;
+
+                fData[6] = value.M13;
+                fData[7] = value.M23;
+                fData[8] = value.M33;
+            }
+            else if (RowCount == 3 && ColumnCount == 2)
+            {
+                var fData = (float[])Data;
+
+                fData[0] = value.M11;
+                fData[1] = value.M21;
+                fData[2] = value.M31;
+
+                fData[3] = value.M12;
+                fData[4] = value.M22;
+                fData[5] = value.M32;
+            }
+
+            StateKey = unchecked(NextStateKey++);
+        }
+
+		public void SetValueTranspose(Matrix value)
+		{
+            if (ParameterClass != EffectParameterClass.Matrix || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+            // HLSL expects matrices to be transposed by default, so copying them straight
+            // from the in-memory version effectively transposes them back to row-major.
+            if (RowCount == 4 && ColumnCount == 4)
+            {
+                var fData = (float[])Data;
+
+                fData[0] = value.M11;
+                fData[1] = value.M12;
+                fData[2] = value.M13;
+                fData[3] = value.M14;
+
+                fData[4] = value.M21;
+                fData[5] = value.M22;
+                fData[6] = value.M23;
+                fData[7] = value.M24;
+
+                fData[8] = value.M31;
+                fData[9] = value.M32;
+                fData[10] = value.M33;
+                fData[11] = value.M34;
+
+                fData[12] = value.M41;
+                fData[13] = value.M42;
+                fData[14] = value.M43;
+                fData[15] = value.M44;
+            }
+            else if (RowCount == 4 && ColumnCount == 3)
+            {
+                var fData = (float[])Data;
+
+                fData[0] = value.M11;
+                fData[1] = value.M12;
+                fData[2] = value.M13;
+
+                fData[3] = value.M21;
+                fData[4] = value.M22;
+                fData[5] = value.M23;
+
+                fData[6] = value.M31;
+                fData[7] = value.M32;
+                fData[8] = value.M33;
+
+                fData[9] = value.M41;
+                fData[10] = value.M42;
+                fData[11] = value.M43;
+            }
+            else if (RowCount == 3 && ColumnCount == 4)
+            {
+                var fData = (float[])Data;
+
+                fData[0] = value.M11;
+                fData[1] = value.M12;
+                fData[2] = value.M13;
+                fData[3] = value.M14;
+
+                fData[4] = value.M21;
+                fData[5] = value.M22;
+                fData[6] = value.M23;
+                fData[7] = value.M24;
+
+                fData[8] = value.M31;
+                fData[9] = value.M32;
+                fData[10] = value.M33;
+                fData[11] = value.M34;
+            }
+            else if (RowCount == 3 && ColumnCount == 3)
+            {
+                var fData = (float[])Data;
+
+                fData[0] = value.M11;
+                fData[1] = value.M12;
+                fData[2] = value.M13;
+
+                fData[3] = value.M21;
+                fData[4] = value.M22;
+                fData[5] = value.M23;
+
+                fData[6] = value.M31;
+                fData[7] = value.M32;
+                fData[8] = value.M33;
+            }
+            else if (RowCount == 3 && ColumnCount == 2)
+            {
+                var fData = (float[])Data;
+
+                fData[0] = value.M11;
+                fData[1] = value.M12;
+                fData[2] = value.M13;
+
+                fData[3] = value.M21;
+                fData[4] = value.M22;
+                fData[5] = value.M23;
+            }
+
+			StateKey = unchecked(NextStateKey++);
+		}
+
+		public void SetValue (Matrix[] value)
+		{
+            if (ParameterClass != EffectParameterClass.Matrix || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+		    if (RowCount == 4 && ColumnCount == 4)
+		    {
+		        for (var i = 0; i < value.Length; i++)
+		        {
+		            var fData = (float[])Elements[i].Data;
+
+		            fData[0] = value[i].M11;
+		            fData[1] = value[i].M21;
+		            fData[2] = value[i].M31;
+		            fData[3] = value[i].M41;
+
+		            fData[4] = value[i].M12;
+		            fData[5] = value[i].M22;
+		            fData[6] = value[i].M32;
+		            fData[7] = value[i].M42;
+
+		            fData[8] = value[i].M13;
+		            fData[9] = value[i].M23;
+		            fData[10] = value[i].M33;
+		            fData[11] = value[i].M43;
+
+		            fData[12] = value[i].M14;
+		            fData[13] = value[i].M24;
+		            fData[14] = value[i].M34;
+		            fData[15] = value[i].M44;
+		        }
+		    }
+		    else if (RowCount == 4 && ColumnCount == 3)
+            {
+                for (var i = 0; i < value.Length; i++)
+                {
+                    var fData = (float[])Elements[i].Data;
+
+                    fData[0] = value[i].M11;
+                    fData[1] = value[i].M21;
+                    fData[2] = value[i].M31;
+                    fData[3] = value[i].M41;
+
+                    fData[4] = value[i].M12;
+                    fData[5] = value[i].M22;
+                    fData[6] = value[i].M32;
+                    fData[7] = value[i].M42;
+
+                    fData[8] = value[i].M13;
+                    fData[9] = value[i].M23;
+                    fData[10] = value[i].M33;
+                    fData[11] = value[i].M43;
+                }
+            }
+            else if (RowCount == 3 && ColumnCount == 4)
+            {
+                for (var i = 0; i < value.Length; i++)
+                {
+                    var fData = (float[])Elements[i].Data;
+
+                    fData[0] = value[i].M11;
+                    fData[1] = value[i].M21;
+                    fData[2] = value[i].M31;
+
+                    fData[3] = value[i].M12;
+                    fData[4] = value[i].M22;
+                    fData[5] = value[i].M32;
+
+                    fData[6] = value[i].M13;
+                    fData[7] = value[i].M23;
+                    fData[8] = value[i].M33;
+
+                    fData[9] = value[i].M14;
+                    fData[10] = value[i].M24;
+                    fData[11] = value[i].M34;
+                }
+            }
+            else if (RowCount == 3 && ColumnCount == 3)
+            {
+                for (var i = 0; i < value.Length; i++)
+                {
+                    var fData = (float[])Elements[i].Data;
+
+                    fData[0] = value[i].M11;
+                    fData[1] = value[i].M21;
+                    fData[2] = value[i].M31;
+
+                    fData[3] = value[i].M12;
+                    fData[4] = value[i].M22;
+                    fData[5] = value[i].M32;
+
+                    fData[6] = value[i].M13;
+                    fData[7] = value[i].M23;
+                    fData[8] = value[i].M33;
+                }
+            }
+            else if (RowCount == 3 && ColumnCount == 2)
+            {
+                for (var i = 0; i < value.Length; i++)
+                {
+                    var fData = (float[])Elements[i].Data;
+
+                    fData[0] = value[i].M11;
+                    fData[1] = value[i].M21;
+                    fData[2] = value[i].M31;
+
+                    fData[3] = value[i].M12;
+                    fData[4] = value[i].M22;
+                    fData[5] = value[i].M32;
+                }
+            }
+
+            StateKey = unchecked(NextStateKey++);
+		}
+
+		public void SetValue (Quaternion value)
+		{
+            if (ParameterClass != EffectParameterClass.Vector || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+            var fData = (float[])Data;
+            fData[0] = value.X;
+            fData[1] = value.Y;
+            fData[2] = value.Z;
+            fData[3] = value.W;
+            StateKey = unchecked(NextStateKey++);
+		}
+
+        /*
+		public void SetValue (Quaternion[] value)
+		{
+			throw new NotImplementedException();
+		}
+        */
+
+		public void SetValue (Single value)
+		{
+            if (ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+			((float[])Data)[0] = value;
+            StateKey = unchecked(NextStateKey++);
+		}
+
+		public void SetValue (Single[] value)
+		{
+			for (var i=0; i<value.Length; i++)
+				Elements[i].SetValue (value[i]);
+
+            StateKey = unchecked(NextStateKey++);
+		}
+		
+        /*
+		public void SetValue (string value)
+		{
+			throw new NotImplementedException();
+		}
+        */
+
+		public void SetValue (Texture value)
+		{
+            if (this.ParameterType != EffectParameterType.Texture && 
+                this.ParameterType != EffectParameterType.Texture1D &&
+                this.ParameterType != EffectParameterType.Texture2D &&
+                this.ParameterType != EffectParameterType.Texture3D &&
+                this.ParameterType != EffectParameterType.TextureCube) 
+            {
+                throw new InvalidCastException();
+            }
+
+			Data = value;
+            StateKey = unchecked(NextStateKey++);
+		}
+
+		public void SetValue (Vector2 value)
+		{
+            if (ParameterClass != EffectParameterClass.Vector || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+            var fData = (float[])Data;
+            fData[0] = value.X;
+            fData[1] = value.Y;
+            StateKey = unchecked(NextStateKey++);
+		}
+
+		public void SetValue (Vector2[] value)
+		{
+            for (var i = 0; i < value.Length; i++)
+				Elements[i].SetValue (value[i]);
+            StateKey = unchecked(NextStateKey++);
+		}
+
+		public void SetValue (Vector3 value)
+		{
+            if (ParameterClass != EffectParameterClass.Vector || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+            var fData = (float[])Data;
+            fData[0] = value.X;
+            fData[1] = value.Y;
+            fData[2] = value.Z;
+            StateKey = unchecked(NextStateKey++);
+		}
+
+		public void SetValue (Vector3[] value)
+		{
+            for (var i = 0; i < value.Length; i++)
+				Elements[i].SetValue (value[i]);
+            StateKey = unchecked(NextStateKey++);
+		}
+
+		public void SetValue (Vector4 value)
+		{
+            if (ParameterClass != EffectParameterClass.Vector || ParameterType != EffectParameterType.Single)
+                throw new InvalidCastException();
+
+			var fData = (float[])Data;
+            fData[0] = value.X;
+            fData[1] = value.Y;
+            fData[2] = value.Z;
+            fData[3] = value.W;
+            StateKey = unchecked(NextStateKey++);
+		}
+
+		public void SetValue (Vector4[] value)
+		{
+            for (var i = 0; i < value.Length; i++)
+				Elements[i].SetValue (value[i]);
+            StateKey = unchecked(NextStateKey++);
+		}
+	}    
+}
diff --git a/MonoGame.Framework/Graphics/Effect/EffectParameterClass.cs b/MonoGame.Framework/Graphics/Effect/EffectParameterClass.cs
new file mode 100644
index 00000000000..b88590c9c6d
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectParameterClass.cs
@@ -0,0 +1,34 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines classes for effect parameters and shader constants.
+    /// </summary>
+	public enum EffectParameterClass
+	{
+        /// <summary>
+        /// Scalar class type.
+        /// </summary>
+		Scalar,
+        /// <summary>
+        /// Vector class type.
+        /// </summary>
+		Vector,
+        /// <summary>
+        /// Matrix class type.
+        /// </summary>
+		Matrix,
+        /// <summary>
+        /// Class type for textures, shaders or strings. 
+        /// </summary>
+		Object,
+        /// <summary>
+        /// Structure class type.
+        /// </summary>
+		Struct
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Effect/EffectParameterCollection.cs b/MonoGame.Framework/Graphics/Effect/EffectParameterCollection.cs
new file mode 100644
index 00000000000..e288edd84b3
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectParameterCollection.cs
@@ -0,0 +1,73 @@
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public class EffectParameterCollection : IEnumerable<EffectParameter>
+    {
+        internal static readonly EffectParameterCollection Empty = new EffectParameterCollection(new EffectParameter[0]);
+
+        private readonly EffectParameter[] _parameters;
+        private readonly Dictionary<string, int> _indexLookup;
+
+        internal EffectParameterCollection(EffectParameter[] parameters)
+        {
+            _parameters = parameters;
+            _indexLookup = new Dictionary<string, int>(_parameters.Length);
+            for (int i = 0; i < _parameters.Length; i++)
+            {
+                string name = _parameters[i].Name;
+                if(!string.IsNullOrWhiteSpace(name))
+                    _indexLookup.Add(name, i);
+            }
+        }
+
+        private EffectParameterCollection(EffectParameter[] parameters, Dictionary<string, int> indexLookup)
+        {
+            _parameters = parameters;
+            _indexLookup = indexLookup;
+        }
+
+        internal EffectParameterCollection Clone()
+        {
+            if (_parameters.Length == 0)
+                return Empty;
+
+            var parameters = new EffectParameter[_parameters.Length];
+            for (var i = 0; i < _parameters.Length; i++)
+                parameters[i] = new EffectParameter(_parameters[i]);
+
+            return new EffectParameterCollection(parameters, _indexLookup);
+        }
+
+        public int Count
+        {
+            get { return _parameters.Length; }
+        }
+		
+		public EffectParameter this[int index]
+		{
+			get { return _parameters[index]; }
+		}
+		
+		public EffectParameter this[string name]
+        {
+            get
+            {
+                int index;
+                if (_indexLookup.TryGetValue(name, out index))
+                    return _parameters[index];
+                return null;
+			}
+        }
+
+        public IEnumerator<EffectParameter> GetEnumerator()
+        {
+            return ((IEnumerable<EffectParameter>)_parameters).GetEnumerator();
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return _parameters.GetEnumerator();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Effect/EffectParameterType.cs b/MonoGame.Framework/Graphics/Effect/EffectParameterType.cs
new file mode 100644
index 00000000000..f7dae62f4c5
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectParameterType.cs
@@ -0,0 +1,53 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	/// <summary>
+	/// Defines types for effect parameters and shader constants.
+	/// </summary>
+	public enum EffectParameterType
+	{
+        /// <summary>
+        /// Pointer to void type.
+        /// </summary>
+		Void,
+        /// <summary>
+        /// Boolean type. Any non-zero will be <c>true</c>; <c>false</c> otherwise.
+        /// </summary>
+		Bool,
+        /// <summary>
+        /// 32-bit integer type.
+        /// </summary>
+		Int32,
+        /// <summary>
+        /// Float type.
+        /// </summary>
+		Single,
+        /// <summary>
+        /// String type.
+        /// </summary>
+		String,
+        /// <summary>
+        /// Any texture type.
+        /// </summary>
+		Texture,
+        /// <summary>
+        /// 1D-texture type.
+        /// </summary>
+        Texture1D,  
+        /// <summary>
+        /// 2D-texture type.
+        /// </summary>
+        Texture2D,
+        /// <summary>
+        /// 3D-texture type.
+        /// </summary>
+        Texture3D,
+        /// <summary>
+        /// Cubic texture type.
+        /// </summary>
+		TextureCube
+	}
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/Effect/EffectPass.cs b/MonoGame.Framework/Graphics/Effect/EffectPass.cs
new file mode 100644
index 00000000000..a2798ff15d5
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectPass.cs
@@ -0,0 +1,133 @@
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public class EffectPass
+    {
+        private readonly Effect _effect;
+
+		private readonly Shader _pixelShader;
+        private readonly Shader _vertexShader;
+
+        private readonly BlendState _blendState;
+        private readonly DepthStencilState _depthStencilState;
+        private readonly RasterizerState _rasterizerState;
+
+		public string Name { get; private set; }
+
+        public EffectAnnotationCollection Annotations { get; private set; }
+
+        internal EffectPass(    Effect effect, 
+                                string name,
+                                Shader vertexShader, 
+                                Shader pixelShader, 
+                                BlendState blendState, 
+                                DepthStencilState depthStencilState, 
+                                RasterizerState rasterizerState,
+                                EffectAnnotationCollection annotations )
+        {
+            Debug.Assert(effect != null, "Got a null effect!");
+            Debug.Assert(annotations != null, "Got a null annotation collection!");
+
+            _effect = effect;
+
+            Name = name;
+
+            _vertexShader = vertexShader;
+            _pixelShader = pixelShader;
+
+            _blendState = blendState;
+            _depthStencilState = depthStencilState;
+            _rasterizerState = rasterizerState;
+
+            Annotations = annotations;
+        }
+        
+        internal EffectPass(Effect effect, EffectPass cloneSource)
+        {
+            Debug.Assert(effect != null, "Got a null effect!");
+            Debug.Assert(cloneSource != null, "Got a null cloneSource!");
+
+            _effect = effect;
+
+            // Share all the immutable types.
+            Name = cloneSource.Name;
+            _blendState = cloneSource._blendState;
+            _depthStencilState = cloneSource._depthStencilState;
+            _rasterizerState = cloneSource._rasterizerState;
+            Annotations = cloneSource.Annotations;
+            _vertexShader = cloneSource._vertexShader;
+            _pixelShader = cloneSource._pixelShader;
+        }
+
+        public void Apply()
+        {
+            // Set/get the correct shader handle/cleanups.
+
+            var current = _effect.CurrentTechnique;
+            _effect.OnApply();
+            if (_effect.CurrentTechnique != current)
+            {
+                _effect.CurrentTechnique.Passes[0].Apply();
+                return;
+            }
+
+            var device = _effect.GraphicsDevice;
+
+            if (_vertexShader != null)
+            {
+                device.VertexShader = _vertexShader;
+
+				// Update the texture parameters.
+                SetShaderSamplers(_vertexShader, device.VertexTextures, device.VertexSamplerStates);
+
+                // Update the constant buffers.
+                for (var c = 0; c < _vertexShader.CBuffers.Length; c++)
+                {
+                    var cb = _effect.ConstantBuffers[_vertexShader.CBuffers[c]];
+                    cb.Update(_effect.Parameters);
+                    device.SetConstantBuffer(ShaderStage.Vertex, c, cb);
+                }
+            }
+
+            if (_pixelShader != null)
+            {
+                device.PixelShader = _pixelShader;
+
+                // Update the texture parameters.
+                SetShaderSamplers(_pixelShader, device.Textures, device.SamplerStates);
+                
+                // Update the constant buffers.
+                for (var c = 0; c < _pixelShader.CBuffers.Length; c++)
+                {
+                    var cb = _effect.ConstantBuffers[_pixelShader.CBuffers[c]];
+                    cb.Update(_effect.Parameters);
+                    device.SetConstantBuffer(ShaderStage.Pixel, c, cb);
+                }
+            }
+
+            // Set the render states if we have some.
+            if (_rasterizerState != null)
+                device.RasterizerState = _rasterizerState;
+            if (_blendState != null)
+                device.BlendState = _blendState;
+            if (_depthStencilState != null)
+                device.DepthStencilState = _depthStencilState;
+        }
+
+        private void SetShaderSamplers(Shader shader, TextureCollection textures, SamplerStateCollection samplerStates)
+        {
+            foreach (var sampler in shader.Samplers)
+            {
+                var param = _effect.Parameters[sampler.parameter];
+                var texture = param.Data as Texture;
+
+                textures[sampler.textureSlot] = texture;
+
+                // If there is a sampler state set it.
+                if (sampler.state != null)
+                    samplerStates[sampler.samplerSlot] = sampler.state;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/Effect/EffectPassCollection.cs b/MonoGame.Framework/Graphics/Effect/EffectPassCollection.cs
new file mode 100644
index 00000000000..429041e61b2
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectPassCollection.cs
@@ -0,0 +1,116 @@
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public class EffectPassCollection : IEnumerable<EffectPass>
+    {
+		private readonly EffectPass[] _passes;
+
+        internal EffectPassCollection(EffectPass [] passes)
+        {
+            _passes = passes;
+        }
+
+        internal EffectPassCollection Clone(Effect effect)
+        {
+            var passes = new EffectPass[_passes.Length];
+            for (var i = 0; i < _passes.Length; i++)
+                passes[i] = new EffectPass(effect, _passes[i]);
+
+            return new EffectPassCollection(passes);
+        }
+
+        public EffectPass this[int index]
+        {
+            get { return _passes[index]; }
+        }
+
+        public EffectPass this[string name]
+        {
+            get 
+            {
+                // TODO: Add a name to pass lookup table.
+				foreach (var pass in _passes) 
+                {
+					if (pass.Name == name)
+						return pass;
+				}
+				return null;
+		    }
+        }
+
+        public int Count
+        {
+            get { return _passes.Length; }
+        }
+
+        public Enumerator GetEnumerator()
+        {
+            return new Enumerator(_passes);
+        }
+            
+        IEnumerator<EffectPass> IEnumerable<EffectPass>.GetEnumerator()
+        {
+            return ((IEnumerable<EffectPass>)_passes).GetEnumerator();
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return _passes.GetEnumerator();
+        }
+
+        public struct Enumerator : IEnumerator<EffectPass>
+        {
+            private readonly EffectPass[] _array;
+            private int _index;
+            private EffectPass _current;
+
+            internal Enumerator(EffectPass[] array)
+            {
+                _array = array;
+                _index = 0;
+                _current = null;
+            }
+
+            public bool MoveNext()
+            {
+                if (_index < _array.Length)
+                {
+                    _current = _array[_index];
+                    _index++;
+                    return true;
+                }
+                _index = _array.Length + 1;
+                _current = null;
+                return false;
+            }
+
+            public EffectPass Current
+            {
+                get { return _current; }
+            }
+
+            public void Dispose()
+            {
+
+            }
+
+            object System.Collections.IEnumerator.Current
+            {
+                get
+                {
+                    if (_index == _array.Length + 1)
+                        throw new InvalidOperationException();
+                    return Current;
+                }
+            }
+
+            void System.Collections.IEnumerator.Reset()
+            {
+                _index = 0;
+                _current = null;
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Effect/EffectResource.DirectX.cs b/MonoGame.Framework/Graphics/Effect/EffectResource.DirectX.cs
new file mode 100644
index 00000000000..eecc3c27c09
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectResource.DirectX.cs
@@ -0,0 +1,16 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal partial class EffectResource
+    {
+        const string AlphaTestEffectName = "Microsoft.Xna.Framework.Graphics.Effect.Resources.AlphaTestEffect.dx11.mgfxo";
+        const string BasicEffectName = "Microsoft.Xna.Framework.Graphics.Effect.Resources.BasicEffect.dx11.mgfxo";
+        const string DualTextureEffectName = "Microsoft.Xna.Framework.Graphics.Effect.Resources.DualTextureEffect.dx11.mgfxo";
+        const string EnvironmentMapEffectName = "Microsoft.Xna.Framework.Graphics.Effect.Resources.EnvironmentMapEffect.dx11.mgfxo";
+        const string SkinnedEffectName = "Microsoft.Xna.Framework.Graphics.Effect.Resources.SkinnedEffect.dx11.mgfxo";
+        const string SpriteEffectName = "Microsoft.Xna.Framework.Graphics.Effect.Resources.SpriteEffect.dx11.mgfxo";
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Effect/EffectResource.OpenGL.cs b/MonoGame.Framework/Graphics/Effect/EffectResource.OpenGL.cs
new file mode 100644
index 00000000000..86f6d894b06
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectResource.OpenGL.cs
@@ -0,0 +1,16 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal partial class EffectResource
+    {
+        const string AlphaTestEffectName = "Microsoft.Xna.Framework.Graphics.Effect.Resources.AlphaTestEffect.ogl.mgfxo";
+        const string BasicEffectName = "Microsoft.Xna.Framework.Graphics.Effect.Resources.BasicEffect.ogl.mgfxo";
+        const string DualTextureEffectName = "Microsoft.Xna.Framework.Graphics.Effect.Resources.DualTextureEffect.ogl.mgfxo";
+        const string EnvironmentMapEffectName = "Microsoft.Xna.Framework.Graphics.Effect.Resources.EnvironmentMapEffect.ogl.mgfxo";
+        const string SkinnedEffectName = "Microsoft.Xna.Framework.Graphics.Effect.Resources.SkinnedEffect.ogl.mgfxo";
+        const string SpriteEffectName = "Microsoft.Xna.Framework.Graphics.Effect.Resources.SpriteEffect.ogl.mgfxo";
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Effect/EffectResource.cs b/MonoGame.Framework/Graphics/Effect/EffectResource.cs
new file mode 100644
index 00000000000..b0f09d6aaa8
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectResource.cs
@@ -0,0 +1,57 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.IO;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Internal helper for accessing the bytecode for stock effects.
+    /// </summary>
+    internal partial class EffectResource
+    {
+        public static readonly EffectResource AlphaTestEffect = new EffectResource(AlphaTestEffectName);
+        public static readonly EffectResource BasicEffect = new EffectResource(BasicEffectName);
+        public static readonly EffectResource DualTextureEffect = new EffectResource(DualTextureEffectName);
+        public static readonly EffectResource EnvironmentMapEffect = new EffectResource(EnvironmentMapEffectName);
+        public static readonly EffectResource SkinnedEffect = new EffectResource(SkinnedEffectName);
+        public static readonly EffectResource SpriteEffect = new EffectResource(SpriteEffectName);
+
+        private readonly object _locker = new object();
+        private readonly string _name;
+        private volatile byte[] _bytecode;
+
+        private EffectResource(string name)
+        {
+            _name = name;
+        }
+
+        public byte[] Bytecode
+        {
+            get
+            {
+                if (_bytecode == null)
+                {
+                    lock (_locker)
+                    {
+                        if (_bytecode != null)
+                            return _bytecode;
+
+                        var assembly = ReflectionHelpers.GetAssembly(typeof(EffectResource));
+
+                        var stream = assembly.GetManifestResourceStream(_name);
+                        using (var ms = new MemoryStream())
+                        {
+                            stream.CopyTo(ms);
+                            _bytecode = ms.ToArray();
+                        }
+                    }
+                }
+
+                return _bytecode;
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Effect/EffectTechnique.cs b/MonoGame.Framework/Graphics/Effect/EffectTechnique.cs
new file mode 100644
index 00000000000..c3a58813d04
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectTechnique.cs
@@ -0,0 +1,32 @@
+using System;
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public class EffectTechnique
+	{
+        public EffectPassCollection Passes { get; private set; }
+
+        public EffectAnnotationCollection Annotations { get; private set; }
+
+        public string Name { get; private set; }
+
+        internal EffectTechnique(Effect effect, EffectTechnique cloneSource)
+        {
+            // Share all the immutable types.
+            Name = cloneSource.Name;
+            Annotations = cloneSource.Annotations;
+
+            // Clone the mutable types.
+            Passes = cloneSource.Passes.Clone(effect);
+        }
+
+        internal EffectTechnique(Effect effect, string name, EffectPassCollection passes, EffectAnnotationCollection annotations)
+        {
+            Name = name;
+            Passes = passes;
+            Annotations = annotations;
+        }
+    }
+
+
+}
+
diff --git a/MonoGame.Framework/Graphics/Effect/EffectTechniqueCollection.cs b/MonoGame.Framework/Graphics/Effect/EffectTechniqueCollection.cs
new file mode 100644
index 00000000000..113298523a5
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EffectTechniqueCollection.cs
@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public class EffectTechniqueCollection : IEnumerable<EffectTechnique>
+    {
+		private readonly EffectTechnique[] _techniques;
+
+        public int Count { get { return _techniques.Length; } }
+
+        internal EffectTechniqueCollection(EffectTechnique[] techniques)
+        {
+            _techniques = techniques;
+        }
+
+        internal EffectTechniqueCollection Clone(Effect effect)
+        {
+            var techniques = new EffectTechnique[_techniques.Length];
+            for (var i = 0; i < _techniques.Length; i++)
+                techniques[i] = new EffectTechnique(effect, _techniques[i]);
+
+            return new EffectTechniqueCollection(techniques);
+        }
+        
+        public EffectTechnique this[int index]
+        {
+            get { return _techniques [index]; }
+        }
+
+        public EffectTechnique this[string name]
+        {
+            get 
+            {
+                // TODO: Add a name to technique lookup table.
+				foreach (var technique in _techniques) 
+                {
+					if (technique.Name == name)
+						return technique;
+			    }
+
+			    return null;
+		    }
+        }
+
+        public IEnumerator<EffectTechnique> GetEnumerator()
+        {
+            return ((IEnumerable<EffectTechnique>)_techniques).GetEnumerator();
+        }
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return _techniques.GetEnumerator();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Effect/EnvironmentMapEffect.cs b/MonoGame.Framework/Graphics/Effect/EnvironmentMapEffect.cs
new file mode 100644
index 00000000000..00067b03e9e
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/EnvironmentMapEffect.cs
@@ -0,0 +1,510 @@
+#region File Description
+//-----------------------------------------------------------------------------
+// EnvironmentMapEffect.cs
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+#endregion
+
+#region Using Statements
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+#endregion
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Built-in effect that supports environment mapping.
+    /// </summary>
+    public class EnvironmentMapEffect : Effect, IEffectMatrices, IEffectLights, IEffectFog
+    {
+        #region Effect Parameters
+
+        EffectParameter textureParam;
+        EffectParameter environmentMapParam;
+        EffectParameter environmentMapAmountParam;
+        EffectParameter environmentMapSpecularParam;
+        EffectParameter fresnelFactorParam;
+        EffectParameter diffuseColorParam;
+        EffectParameter emissiveColorParam;
+        EffectParameter eyePositionParam;
+        EffectParameter fogColorParam;
+        EffectParameter fogVectorParam;
+        EffectParameter worldParam;
+        EffectParameter worldInverseTransposeParam;
+        EffectParameter worldViewProjParam;
+
+        #endregion
+
+        #region Fields
+
+        bool oneLight;
+        bool fogEnabled;
+        bool fresnelEnabled;
+        bool specularEnabled;
+
+        Matrix world = Matrix.Identity;
+        Matrix view = Matrix.Identity;
+        Matrix projection = Matrix.Identity;
+
+        Matrix worldView;
+
+        Vector3 diffuseColor = Vector3.One;
+        Vector3 emissiveColor = Vector3.Zero;
+        Vector3 ambientLightColor = Vector3.Zero;
+
+        float alpha = 1;
+
+        DirectionalLight light0;
+        DirectionalLight light1;
+        DirectionalLight light2;
+
+        float fogStart = 0;
+        float fogEnd = 1;
+
+        EffectDirtyFlags dirtyFlags = EffectDirtyFlags.All;
+
+        #endregion
+
+        #region Public Properties
+
+
+        /// <summary>
+        /// Gets or sets the world matrix.
+        /// </summary>
+        public Matrix World
+        {
+            get { return world; }
+            
+            set
+            {
+                world = value;
+                dirtyFlags |= EffectDirtyFlags.World | EffectDirtyFlags.WorldViewProj | EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the view matrix.
+        /// </summary>
+        public Matrix View
+        {
+            get { return view; }
+            
+            set
+            {
+                view = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj | EffectDirtyFlags.EyePosition | EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the projection matrix.
+        /// </summary>
+        public Matrix Projection
+        {
+            get { return projection; }
+            
+            set
+            {
+                projection = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material diffuse color (range 0 to 1).
+        /// </summary>
+        public Vector3 DiffuseColor
+        {
+            get { return diffuseColor; }
+            
+            set
+            {
+                diffuseColor = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material emissive color (range 0 to 1).
+        /// </summary>
+        public Vector3 EmissiveColor
+        {
+            get { return emissiveColor; }
+            
+            set
+            {
+                emissiveColor = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material alpha.
+        /// </summary>
+        public float Alpha
+        {
+            get { return alpha; }
+            
+            set
+            {
+                alpha = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the ambient light color (range 0 to 1).
+        /// </summary>
+        public Vector3 AmbientLightColor
+        {
+            get { return ambientLightColor; }
+            
+            set
+            {
+                ambientLightColor = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets the first directional light.
+        /// </summary>
+        public DirectionalLight DirectionalLight0 { get { return light0; } }
+
+
+        /// <summary>
+        /// Gets the second directional light.
+        /// </summary>
+        public DirectionalLight DirectionalLight1 { get { return light1; } }
+
+
+        /// <summary>
+        /// Gets the third directional light.
+        /// </summary>
+        public DirectionalLight DirectionalLight2 { get { return light2; } }
+
+
+        /// <summary>
+        /// Gets or sets the fog enable flag.
+        /// </summary>
+        public bool FogEnabled
+        {
+            get { return fogEnabled; }
+            
+            set
+            {
+                if (fogEnabled != value)
+                {
+                    fogEnabled = value;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex | EffectDirtyFlags.FogEnable;
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog start distance.
+        /// </summary>
+        public float FogStart
+        {
+            get { return fogStart; }
+            
+            set
+            {
+                fogStart = value;
+                dirtyFlags |= EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog end distance.
+        /// </summary>
+        public float FogEnd
+        {
+            get { return fogEnd; }
+            
+            set
+            {
+                fogEnd = value;
+                dirtyFlags |= EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog color.
+        /// </summary>
+        public Vector3 FogColor
+        {
+            get { return fogColorParam.GetValueVector3(); }
+            set { fogColorParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the current texture.
+        /// </summary>
+        public Texture2D Texture
+        {
+            get { return textureParam.GetValueTexture2D(); }
+            set { textureParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the current environment map texture.
+        /// </summary>
+        public TextureCube EnvironmentMap
+        {
+            get { return environmentMapParam.GetValueTextureCube(); }
+            set { environmentMapParam.SetValue(value); }
+        }
+        
+        
+        /// <summary>
+        /// Gets or sets the amount of the environment map RGB that will be blended over 
+        /// the base texture. Range 0 to 1, default 1. If set to zero, the RGB channels 
+        /// of the environment map will completely ignored (but the environment map alpha 
+        /// may still be visible if EnvironmentMapSpecular is greater than zero).
+        /// </summary>
+        public float EnvironmentMapAmount
+        {
+            get { return environmentMapAmountParam.GetValueSingle(); }
+            set { environmentMapAmountParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the amount of the environment map alpha channel that will 
+        /// be added to the base texture. Range 0 to 1, default 0. This can be used 
+        /// to implement cheap specular lighting, by encoding one or more specular 
+        /// highlight patterns into the environment map alpha channel, then setting 
+        /// EnvironmentMapSpecular to the desired specular light color.
+        /// </summary>
+        public Vector3 EnvironmentMapSpecular
+        {
+            get { return environmentMapSpecularParam.GetValueVector3(); }
+
+            set
+            {
+                environmentMapSpecularParam.SetValue(value);
+                
+                bool enabled = (value != Vector3.Zero);
+                
+                if (specularEnabled != enabled)
+                {
+                    specularEnabled = enabled;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex;
+                }
+            }
+        }
+        
+        
+        /// <summary>
+        /// Gets or sets the Fresnel factor used for the environment map blending. 
+        /// Higher values make the environment map only visible around the silhouette 
+        /// edges of the object, while lower values make it visible everywhere. 
+        /// Setting this property to 0 disables Fresnel entirely, making the 
+        /// environment map equally visible regardless of view angle. The default is 
+        /// 1. Fresnel only affects the environment map RGB (the intensity of which is 
+        /// controlled by EnvironmentMapAmount). The alpha contribution (controlled by 
+        /// EnvironmentMapSpecular) is not affected by the Fresnel setting.
+        /// </summary>
+        public float FresnelFactor
+        {
+            get { return fresnelFactorParam.GetValueSingle(); }
+
+            set
+            {
+                fresnelFactorParam.SetValue(value);
+                
+                bool enabled = (value != 0);
+                
+                if (fresnelEnabled != enabled)
+                {
+                    fresnelEnabled = enabled;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex;
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// This effect requires lighting, so we explicitly implement
+        /// IEffectLights.LightingEnabled, and do not allow turning it off.
+        /// </summary>
+        bool IEffectLights.LightingEnabled
+        {
+            get { return true; }
+            set { if (!value) throw new NotSupportedException("EnvironmentMapEffect does not support setting LightingEnabled to false."); }
+        }
+
+
+        #endregion
+
+        #region Methods
+
+
+        /// <summary>
+        /// Creates a new EnvironmentMapEffect with default parameter settings.
+        /// </summary>
+        public EnvironmentMapEffect(GraphicsDevice device)
+            : base(device, EffectResource.EnvironmentMapEffect.Bytecode)
+        {
+            CacheEffectParameters(null);
+
+            DirectionalLight0.Enabled = true;
+
+            EnvironmentMapAmount = 1;
+            EnvironmentMapSpecular = Vector3.Zero;
+            FresnelFactor = 1;
+        }
+
+
+        /// <summary>
+        /// Creates a new EnvironmentMapEffect by cloning parameter settings from an existing instance.
+        /// </summary>
+        protected EnvironmentMapEffect(EnvironmentMapEffect cloneSource)
+            : base(cloneSource)
+        {
+            CacheEffectParameters(cloneSource);
+
+            fogEnabled = cloneSource.fogEnabled;
+            fresnelEnabled = cloneSource.fresnelEnabled;
+            specularEnabled = cloneSource.specularEnabled;
+
+            world = cloneSource.world;
+            view = cloneSource.view;
+            projection = cloneSource.projection;
+
+            diffuseColor = cloneSource.diffuseColor;
+            emissiveColor = cloneSource.emissiveColor;
+            ambientLightColor = cloneSource.ambientLightColor;
+
+            alpha = cloneSource.alpha;
+
+            fogStart = cloneSource.fogStart;
+            fogEnd = cloneSource.fogEnd;
+        }
+
+
+        /// <summary>
+        /// Creates a clone of the current EnvironmentMapEffect instance.
+        /// </summary>
+        public override Effect Clone()
+        {
+            return new EnvironmentMapEffect(this);
+        }
+
+
+        /// <summary>
+        /// Sets up the standard key/fill/back lighting rig.
+        /// </summary>
+        public void EnableDefaultLighting()
+        {
+            AmbientLightColor = EffectHelpers.EnableDefaultLighting(light0, light1, light2);
+        }
+
+
+        /// <summary>
+        /// Looks up shortcut references to our effect parameters.
+        /// </summary>
+        void CacheEffectParameters(EnvironmentMapEffect cloneSource)
+        {
+            textureParam                = Parameters["Texture"];
+            environmentMapParam         = Parameters["EnvironmentMap"];
+            environmentMapAmountParam   = Parameters["EnvironmentMapAmount"];
+            environmentMapSpecularParam = Parameters["EnvironmentMapSpecular"];
+            fresnelFactorParam          = Parameters["FresnelFactor"];
+            diffuseColorParam           = Parameters["DiffuseColor"];
+            emissiveColorParam          = Parameters["EmissiveColor"];
+            eyePositionParam            = Parameters["EyePosition"];
+            fogColorParam               = Parameters["FogColor"];
+            fogVectorParam              = Parameters["FogVector"];
+            worldParam                  = Parameters["World"];
+            worldInverseTransposeParam  = Parameters["WorldInverseTranspose"];
+            worldViewProjParam          = Parameters["WorldViewProj"];
+
+            light0 = new DirectionalLight(Parameters["DirLight0Direction"],
+                                          Parameters["DirLight0DiffuseColor"],
+                                          null,
+                                          (cloneSource != null) ? cloneSource.light0 : null);
+
+            light1 = new DirectionalLight(Parameters["DirLight1Direction"],
+                                          Parameters["DirLight1DiffuseColor"],
+                                          null,
+                                          (cloneSource != null) ? cloneSource.light1 : null);
+
+            light2 = new DirectionalLight(Parameters["DirLight2Direction"],
+                                          Parameters["DirLight2DiffuseColor"],
+                                          null,
+                                          (cloneSource != null) ? cloneSource.light2 : null);
+        }
+
+
+        /// <summary>
+        /// Lazily computes derived parameter values immediately before applying the effect.
+        /// </summary>
+        protected internal override void OnApply()
+        {
+            // Recompute the world+view+projection matrix or fog vector?
+            dirtyFlags = EffectHelpers.SetWorldViewProjAndFog(dirtyFlags, ref world, ref view, ref projection, ref worldView, fogEnabled, fogStart, fogEnd, worldViewProjParam, fogVectorParam);
+
+            // Recompute the world inverse transpose and eye position?
+            dirtyFlags = EffectHelpers.SetLightingMatrices(dirtyFlags, ref world, ref view, worldParam, worldInverseTransposeParam, eyePositionParam);
+            
+            // Recompute the diffuse/emissive/alpha material color parameters?
+            if ((dirtyFlags & EffectDirtyFlags.MaterialColor) != 0)
+            {
+                EffectHelpers.SetMaterialColor(true, alpha, ref diffuseColor, ref emissiveColor, ref ambientLightColor, diffuseColorParam, emissiveColorParam);
+
+                dirtyFlags &= ~EffectDirtyFlags.MaterialColor;
+            }
+
+            // Check if we can use the only-bother-with-the-first-light shader optimization.
+            bool newOneLight = !light1.Enabled && !light2.Enabled;
+            
+            if (oneLight != newOneLight)
+            {
+                oneLight = newOneLight;
+                dirtyFlags |= EffectDirtyFlags.ShaderIndex;
+            }
+
+            // Recompute the shader index?
+            if ((dirtyFlags & EffectDirtyFlags.ShaderIndex) != 0)
+            {
+                int shaderIndex = 0;
+                
+                if (!fogEnabled)
+                    shaderIndex += 1;
+                
+                if (fresnelEnabled)
+                    shaderIndex += 2;
+                
+                if (specularEnabled)
+                    shaderIndex += 4;
+
+                if (oneLight)
+                    shaderIndex += 8;
+
+                dirtyFlags &= ~EffectDirtyFlags.ShaderIndex;
+
+                CurrentTechnique = Techniques[shaderIndex];
+            }
+        }
+
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Effect/IEffectFog.cs b/MonoGame.Framework/Graphics/Effect/IEffectFog.cs
new file mode 100644
index 00000000000..875088bca50
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/IEffectFog.cs
@@ -0,0 +1,79 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+// 
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// The common effect fog rendering parameters.
+    /// </summary>
+	public interface IEffectFog
+	{
+        /// <summary>
+        /// The floating point fog color.
+        /// </summary>
+		Vector3 FogColor { get; set; }
+
+        /// <summary>
+        /// Used to toggle the rendering of fog.
+        /// </summary>
+		bool FogEnabled { get; set; }
+
+        /// <summary>
+        /// The world space distance from the camera at which fogging is fully applied.
+        /// </summary>
+        /// <remarks>
+        /// FogEnd should be greater than FogStart.  If FogEnd and FogStart 
+        /// are the same value everything is fully fogged.
+        /// </remarks>
+		float FogEnd { get; set; }
+
+        /// <summary>
+        /// The world space distance from the camera at which fogging begins.
+        /// </summary>
+        /// <remarks>
+        /// FogStart should be less than FogEnd.  If FogEnd and FogStart are the
+        /// same value everything is fully fogged.
+        /// </remarks>
+		float FogStart { get; set; }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Effect/IEffectLights.cs b/MonoGame.Framework/Graphics/Effect/IEffectLights.cs
new file mode 100644
index 00000000000..4145ebb0b11
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/IEffectLights.cs
@@ -0,0 +1,81 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+// 
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// The common effect light rendering parameters.
+    /// </summary>
+	public interface IEffectLights
+	{
+        /// <summary>
+        /// The floating point ambient light color.
+        /// </summary>
+		Vector3 AmbientLightColor { get; set; }
+
+        /// <summary>
+        /// Returns the first directional light.
+        /// </summary>
+		DirectionalLight DirectionalLight0 { get; }
+
+        /// <summary>
+        /// Returns the second directional light.
+        /// </summary>
+		DirectionalLight DirectionalLight1 { get; }
+
+        /// <summary>
+        /// Returns the third directional light.
+        /// </summary>
+		DirectionalLight DirectionalLight2 { get; }
+
+        /// <summary>
+        /// Toggles the rendering of lighting.
+        /// </summary>
+		bool LightingEnabled { get; set; }
+
+        /// <summary>
+        /// Initializes the lights to the standard key/fill/back lighting rig.
+        /// </summary>
+		void EnableDefaultLighting ();
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Effect/IEffectMatrices.cs b/MonoGame.Framework/Graphics/Effect/IEffectMatrices.cs
new file mode 100644
index 00000000000..cfec82c672a
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/IEffectMatrices.cs
@@ -0,0 +1,52 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+// 
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public interface IEffectMatrices
+	{
+		Matrix Projection { get; set; }
+		Matrix View { get; set; }
+		Matrix World { get; set; }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/AlphaTestEffect.dx11.mgfxo b/MonoGame.Framework/Graphics/Effect/Resources/AlphaTestEffect.dx11.mgfxo
new file mode 100644
index 00000000000..dce37ff8108
Binary files /dev/null and b/MonoGame.Framework/Graphics/Effect/Resources/AlphaTestEffect.dx11.mgfxo differ
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/AlphaTestEffect.fx b/MonoGame.Framework/Graphics/Effect/Resources/AlphaTestEffect.fx
new file mode 100644
index 00000000000..bc3d0a56ad2
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/Resources/AlphaTestEffect.fx
@@ -0,0 +1,151 @@
+//-----------------------------------------------------------------------------
+// AlphaTestEffect.fx
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+#include "Macros.fxh"
+
+
+DECLARE_TEXTURE(Texture, 0);
+
+
+BEGIN_CONSTANTS
+
+    float4 DiffuseColor     _vs(c0) _cb(c0);
+    float4 AlphaTest        _ps(c0) _cb(c1);
+    float3 FogColor         _ps(c1) _cb(c2);
+    float4 FogVector        _vs(c5) _cb(c3);
+
+MATRIX_CONSTANTS
+
+    float4x4 WorldViewProj  _vs(c1) _cb(c0);
+
+END_CONSTANTS
+
+
+#include "Structures.fxh"
+#include "Common.fxh"
+
+
+// Vertex shader: basic.
+VSOutputTx VSAlphaTest(VSInputTx vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: no fog.
+VSOutputTxNoFog VSAlphaTestNoFog(VSInputTx vin)
+{
+    VSOutputTxNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: vertex color.
+VSOutputTx VSAlphaTestVc(VSInputTxVc vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex color, no fog.
+VSOutputTxNoFog VSAlphaTestVcNoFog(VSInputTxVc vin)
+{
+    VSOutputTxNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Pixel shader: less/greater compare function.
+float4 PSAlphaTestLtGt(VSOutputTx pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+
+    clip((color.a < AlphaTest.x) ? AlphaTest.z : AlphaTest.w);
+
+    ApplyFog(color, pin.Specular.w);
+
+    return color;
+}
+
+
+// Pixel shader: less/greater compare function, no fog.
+float4 PSAlphaTestLtGtNoFog(VSOutputTxNoFog pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    
+    clip((color.a < AlphaTest.x) ? AlphaTest.z : AlphaTest.w);
+
+    return color;
+}
+
+
+// Pixel shader: equal/notequal compare function.
+float4 PSAlphaTestEqNe(VSOutputTx pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    
+    clip((abs(color.a - AlphaTest.x) < AlphaTest.y) ? AlphaTest.z : AlphaTest.w);
+
+    ApplyFog(color, pin.Specular.w);
+    
+    return color;
+}
+
+
+// Pixel shader: equal/notequal compare function, no fog.
+float4 PSAlphaTestEqNeNoFog(VSOutputTxNoFog pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    
+    clip((abs(color.a - AlphaTest.x) < AlphaTest.y) ? AlphaTest.z : AlphaTest.w);
+
+    return color;
+}
+
+
+// NOTE: The order of the techniques here are
+// defined to match the indexing in AlphaTestEffect.cs.
+
+TECHNIQUE( AlphaTestEffect_LTGT,					VSAlphaTest,		PSAlphaTestLtGt );
+TECHNIQUE( AlphaTestEffect_LTGT_NoFog,				VSAlphaTestNoFog,	PSAlphaTestLtGtNoFog );
+TECHNIQUE( AlphaTestEffect_LTGT_VertexColor,		VSAlphaTestVc,		PSAlphaTestLtGt );
+TECHNIQUE( AlphaTestEffect_LTGT_VertexColor_NoFog,	VSAlphaTestVcNoFog,	PSAlphaTestLtGtNoFog );
+
+TECHNIQUE( AlphaTestEffect_EQNE,					VSAlphaTest,		PSAlphaTestEqNe );
+TECHNIQUE( AlphaTestEffect_EQNE_NoFog,				VSAlphaTestNoFog,	PSAlphaTestEqNeNoFog );
+TECHNIQUE( AlphaTestEffect_EQNE_VertexColor,		VSAlphaTestVc,		PSAlphaTestEqNe );
+TECHNIQUE( AlphaTestEffect_EQNE_VertexColor_NoFog,	VSAlphaTestVcNoFog,	PSAlphaTestEqNeNoFog );
+
+
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/AlphaTestEffect.ogl.mgfxo b/MonoGame.Framework/Graphics/Effect/Resources/AlphaTestEffect.ogl.mgfxo
new file mode 100644
index 00000000000..3c69f43f230
Binary files /dev/null and b/MonoGame.Framework/Graphics/Effect/Resources/AlphaTestEffect.ogl.mgfxo differ
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/BasicEffect.dx11.mgfxo b/MonoGame.Framework/Graphics/Effect/Resources/BasicEffect.dx11.mgfxo
new file mode 100644
index 00000000000..fa9c11234bf
Binary files /dev/null and b/MonoGame.Framework/Graphics/Effect/Resources/BasicEffect.dx11.mgfxo differ
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/BasicEffect.fx b/MonoGame.Framework/Graphics/Effect/Resources/BasicEffect.fx
new file mode 100644
index 00000000000..fc2ae2a599d
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/Resources/BasicEffect.fx
@@ -0,0 +1,490 @@
+//-----------------------------------------------------------------------------
+// BasicEffect.fx
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+#include "Macros.fxh"
+
+
+DECLARE_TEXTURE(Texture, 0);
+
+
+BEGIN_CONSTANTS
+
+    float4 DiffuseColor             _vs(c0)  _ps(c1)  _cb(c0);
+    float3 EmissiveColor            _vs(c1)  _ps(c2)  _cb(c1);
+    float3 SpecularColor            _vs(c2)  _ps(c3)  _cb(c2);
+    float  SpecularPower            _vs(c3)  _ps(c4)  _cb(c2.w);
+
+    float3 DirLight0Direction       _vs(c4)  _ps(c5)  _cb(c3);
+    float3 DirLight0DiffuseColor    _vs(c5)  _ps(c6)  _cb(c4);
+    float3 DirLight0SpecularColor   _vs(c6)  _ps(c7)  _cb(c5);
+
+    float3 DirLight1Direction       _vs(c7)  _ps(c8)  _cb(c6);
+    float3 DirLight1DiffuseColor    _vs(c8)  _ps(c9)  _cb(c7);
+    float3 DirLight1SpecularColor   _vs(c9)  _ps(c10) _cb(c8);
+
+    float3 DirLight2Direction       _vs(c10) _ps(c11) _cb(c9);
+    float3 DirLight2DiffuseColor    _vs(c11) _ps(c12) _cb(c10);
+    float3 DirLight2SpecularColor   _vs(c12) _ps(c13) _cb(c11);
+
+    float3 EyePosition              _vs(c13) _ps(c14) _cb(c12);
+
+    float3 FogColor                          _ps(c0)  _cb(c13);
+    float4 FogVector                _vs(c14)          _cb(c14);
+
+    float4x4 World                  _vs(c19)          _cb(c15);
+    float3x3 WorldInverseTranspose  _vs(c23)          _cb(c19);
+
+MATRIX_CONSTANTS
+
+    float4x4 WorldViewProj          _vs(c15)          _cb(c0);
+
+END_CONSTANTS
+
+
+#include "Structures.fxh"
+#include "Common.fxh"
+#include "Lighting.fxh"
+
+
+// Vertex shader: basic.
+VSOutput VSBasic(VSInput vin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParams;
+    
+    return vout;
+}
+
+
+// Vertex shader: no fog.
+VSOutputNoFog VSBasicNoFog(VSInput vin)
+{
+    VSOutputNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex color.
+VSOutput VSBasicVc(VSInputVc vin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParams;
+    
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex color, no fog.
+VSOutputNoFog VSBasicVcNoFog(VSInputVc vin)
+{
+    VSOutputNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: texture.
+VSOutputTx VSBasicTx(VSInputTx vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: texture, no fog.
+VSOutputTxNoFog VSBasicTxNoFog(VSInputTx vin)
+{
+    VSOutputTxNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: texture + vertex color.
+VSOutputTx VSBasicTxVc(VSInputTxVc vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: texture + vertex color, no fog.
+VSOutputTxNoFog VSBasicTxVcNoFog(VSInputTxVc vin)
+{
+    VSOutputTxNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting.
+VSOutput VSBasicVertexLighting(VSInputNm vin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting + vertex color.
+VSOutput VSBasicVertexLightingVc(VSInputNmVc vin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting + texture.
+VSOutputTx VSBasicVertexLightingTx(VSInputNmTx vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting + texture + vertex color.
+VSOutputTx VSBasicVertexLightingTxVc(VSInputNmTxVc vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: one light.
+VSOutput VSBasicOneLight(VSInputNm vin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    return vout;
+}
+
+
+// Vertex shader: one light + vertex color.
+VSOutput VSBasicOneLightVc(VSInputNmVc vin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: one light + texture.
+VSOutputTx VSBasicOneLightTx(VSInputNmTx vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: one light + texture + vertex color.
+VSOutputTx VSBasicOneLightTxVc(VSInputNmTxVc vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting.
+VSOutputPixelLighting VSBasicPixelLighting(VSInputNm vin)
+{
+    VSOutputPixelLighting vout;
+    
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+
+    vout.Diffuse = float4(1, 1, 1, DiffuseColor.a);
+    
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting + vertex color.
+VSOutputPixelLighting VSBasicPixelLightingVc(VSInputNmVc vin)
+{
+    VSOutputPixelLighting vout;
+    
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+    
+    vout.Diffuse.rgb = vin.Color.rgb;
+    vout.Diffuse.a = vin.Color.a * DiffuseColor.a;
+    
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting + texture.
+VSOutputPixelLightingTx VSBasicPixelLightingTx(VSInputNmTx vin)
+{
+    VSOutputPixelLightingTx vout;
+    
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+    
+    vout.Diffuse = float4(1, 1, 1, DiffuseColor.a);
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting + texture + vertex color.
+VSOutputPixelLightingTx VSBasicPixelLightingTxVc(VSInputNmTxVc vin)
+{
+    VSOutputPixelLightingTx vout;
+    
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+    
+    vout.Diffuse.rgb = vin.Color.rgb;
+    vout.Diffuse.a = vin.Color.a * DiffuseColor.a;
+    vout.TexCoord = vin.TexCoord;
+    
+    return vout;
+}
+
+
+// Pixel shader: basic.
+float4 PSBasic(VSOutput pin) : SV_Target0
+{
+    float4 color = pin.Diffuse;
+    
+    ApplyFog(color, pin.Specular.w);
+    
+    return color;
+}
+
+
+// Pixel shader: no fog.
+float4 PSBasicNoFog(VSOutputNoFog pin) : SV_Target0
+{
+    return pin.Diffuse;
+}
+
+
+// Pixel shader: texture.
+float4 PSBasicTx(VSOutputTx pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    
+    ApplyFog(color, pin.Specular.w);
+    
+    return color;
+}
+
+
+// Pixel shader: texture, no fog.
+float4 PSBasicTxNoFog(VSOutputTxNoFog pin) : SV_Target0
+{
+    return SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+}
+
+
+// Pixel shader: vertex lighting.
+float4 PSBasicVertexLighting(VSOutput pin) : SV_Target0
+{
+    float4 color = pin.Diffuse;
+
+    AddSpecular(color, pin.Specular.rgb);
+    ApplyFog(color, pin.Specular.w);
+    
+    return color;
+}
+
+
+// Pixel shader: vertex lighting, no fog.
+float4 PSBasicVertexLightingNoFog(VSOutput pin) : SV_Target0
+{
+    float4 color = pin.Diffuse;
+    
+    AddSpecular(color, pin.Specular.rgb);
+    
+    return color;
+}
+
+
+// Pixel shader: vertex lighting + texture.
+float4 PSBasicVertexLightingTx(VSOutputTx pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    
+    AddSpecular(color, pin.Specular.rgb);
+    ApplyFog(color, pin.Specular.w);
+    
+    return color;
+}
+
+
+// Pixel shader: vertex lighting + texture, no fog.
+float4 PSBasicVertexLightingTxNoFog(VSOutputTx pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    
+    AddSpecular(color, pin.Specular.rgb);
+    
+    return color;
+}
+
+
+// Pixel shader: pixel lighting.
+float4 PSBasicPixelLighting(VSOutputPixelLighting pin) : SV_Target0
+{
+    float4 color = pin.Diffuse;
+
+    float3 eyeVector = normalize(EyePosition - pin.PositionWS.xyz);
+    float3 worldNormal = normalize(pin.NormalWS);
+    
+    ColorPair lightResult = ComputeLights(eyeVector, worldNormal, 3);
+
+    color.rgb *= lightResult.Diffuse;
+    
+    AddSpecular(color, lightResult.Specular);
+    ApplyFog(color, pin.PositionWS.w);
+    
+    return color;
+}
+
+
+// Pixel shader: pixel lighting + texture.
+float4 PSBasicPixelLightingTx(VSOutputPixelLightingTx pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    
+    float3 eyeVector = normalize(EyePosition - pin.PositionWS.xyz);
+    float3 worldNormal = normalize(pin.NormalWS);
+    
+    ColorPair lightResult = ComputeLights(eyeVector, worldNormal, 3);
+    
+    color.rgb *= lightResult.Diffuse;
+
+    AddSpecular(color, lightResult.Specular);
+    ApplyFog(color, pin.PositionWS.w);
+    
+    return color;
+}
+
+
+// NOTE: The order of the techniques here are
+// defined to match the indexing in BasicEffect.cs.
+
+TECHNIQUE( BasicEffect,								VSBasic,			PSBasic );
+TECHNIQUE( BasicEffect_NoFog,						VSBasicNoFog,		PSBasicNoFog );
+TECHNIQUE( BasicEffect_VertexColor,					VSBasicVc,			PSBasic );
+TECHNIQUE( BasicEffect_VertexColor_NoFog,			VSBasicVcNoFog,		PSBasicNoFog );
+TECHNIQUE( BasicEffect_Texture,						VSBasicTx,			PSBasicTx );
+TECHNIQUE( BasicEffect_Texture_NoFog,				VSBasicTxNoFog,		PSBasicTxNoFog );
+TECHNIQUE( BasicEffect_Texture_VertexColor,			VSBasicTxVc,		PSBasicTx );
+TECHNIQUE( BasicEffect_Texture_VertexColor_NoFog,	VSBasicTxVcNoFog,	PSBasicTxNoFog );
+
+TECHNIQUE( BasicEffect_VertexLighting,								VSBasicVertexLighting,		PSBasicVertexLighting );
+TECHNIQUE( BasicEffect_VertexLighting_NoFog,						VSBasicVertexLighting,		PSBasicVertexLightingNoFog );
+TECHNIQUE( BasicEffect_VertexLighting_VertexColor,					VSBasicVertexLightingVc,	PSBasicVertexLighting );
+TECHNIQUE( BasicEffect_VertexLighting_VertexColor_NoFog,			VSBasicVertexLightingVc,	PSBasicVertexLightingNoFog );
+TECHNIQUE( BasicEffect_VertexLighting_Texture,						VSBasicVertexLightingTx,	PSBasicVertexLightingTx );
+TECHNIQUE( BasicEffect_VertexLighting_Texture_NoFog,				VSBasicVertexLightingTx,	PSBasicVertexLightingTxNoFog );
+TECHNIQUE( BasicEffect_VertexLighting_Texture_VertexColor,			VSBasicVertexLightingTxVc,	PSBasicVertexLightingTx );
+TECHNIQUE( BasicEffect_VertexLighting_Texture_VertexColor_NoFog,	VSBasicVertexLightingTxVc,	PSBasicVertexLightingTxNoFog );
+
+TECHNIQUE( BasicEffect_OneLight,							VSBasicOneLight,		PSBasicVertexLighting );
+TECHNIQUE( BasicEffect_OneLight_NoFog,						VSBasicOneLight,		PSBasicVertexLightingNoFog );
+TECHNIQUE( BasicEffect_OneLight_VertexColor,				VSBasicOneLightVc,		PSBasicVertexLighting );
+TECHNIQUE( BasicEffect_OneLight_VertexColor_NoFog,			VSBasicOneLightVc,		PSBasicVertexLightingNoFog );
+TECHNIQUE( BasicEffect_OneLight_Texture,					VSBasicOneLightTx,		PSBasicVertexLightingTx );
+TECHNIQUE( BasicEffect_OneLight_Texture_NoFog,				VSBasicOneLightTx,		PSBasicVertexLightingTxNoFog );
+TECHNIQUE( BasicEffect_OneLight_Texture_VertexColor,		VSBasicOneLightTxVc,	PSBasicVertexLightingTx );
+TECHNIQUE( BasicEffect_OneLight_Texture_VertexColor_NoFog,	VSBasicOneLightTxVc,	PSBasicVertexLightingTxNoFog );
+
+TECHNIQUE( BasicEffect_PixelLighting,							VSBasicPixelLighting,		PSBasicPixelLighting );
+TECHNIQUE( BasicEffect_PixelLighting_NoFog,						VSBasicPixelLighting,		PSBasicPixelLighting );
+TECHNIQUE( BasicEffect_PixelLighting_VertexColor,				VSBasicPixelLightingVc,		PSBasicPixelLighting );
+TECHNIQUE( BasicEffect_PixelLighting_VertexColor_NoFog,			VSBasicPixelLightingVc,		PSBasicPixelLighting );
+TECHNIQUE( BasicEffect_PixelLighting_Texture,					VSBasicPixelLightingTx,		PSBasicPixelLightingTx );
+TECHNIQUE( BasicEffect_PixelLighting_Texture_NoFog,				VSBasicPixelLightingTx,		PSBasicPixelLightingTx );
+TECHNIQUE( BasicEffect_PixelLighting_Texture_VertexColor,		VSBasicPixelLightingTxVc,	PSBasicPixelLightingTx );
+TECHNIQUE( BasicEffect_PixelLighting_Texture_VertexColor_NoFog,	VSBasicPixelLightingTxVc,	PSBasicPixelLightingTx );
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/BasicEffect.ogl.mgfxo b/MonoGame.Framework/Graphics/Effect/Resources/BasicEffect.ogl.mgfxo
new file mode 100644
index 00000000000..233d027ddb1
Binary files /dev/null and b/MonoGame.Framework/Graphics/Effect/Resources/BasicEffect.ogl.mgfxo differ
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/Common.fxh b/MonoGame.Framework/Graphics/Effect/Resources/Common.fxh
new file mode 100644
index 00000000000..33f121be040
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/Resources/Common.fxh
@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------------
+// Common.fxh
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+
+float ComputeFogFactor(float4 position)
+{
+    return saturate(dot(position, FogVector));
+}
+
+
+void ApplyFog(inout float4 color, float fogFactor)
+{
+    color.rgb = lerp(color.rgb, FogColor * color.a, fogFactor);
+}
+
+
+void AddSpecular(inout float4 color, float3 specular)
+{
+    color.rgb += specular * color.a;
+}
+
+
+struct CommonVSOutput
+{
+    float4 Pos_ps;
+    float4 Diffuse;
+    float3 Specular;
+    float  FogFactor;
+};
+
+
+CommonVSOutput ComputeCommonVSOutput(float4 position)
+{
+    CommonVSOutput vout;
+    
+    vout.Pos_ps = mul(position, WorldViewProj);
+    vout.Diffuse = DiffuseColor;
+    vout.Specular = 0;
+    vout.FogFactor = ComputeFogFactor(position);
+    
+    return vout;
+}
+
+
+#define SetCommonVSOutputParams \
+    vout.PositionPS = cout.Pos_ps; \
+    vout.Diffuse = cout.Diffuse; \
+    vout.Specular = float4(cout.Specular, cout.FogFactor);
+
+
+#define SetCommonVSOutputParamsNoFog \
+    vout.PositionPS = cout.Pos_ps; \
+    vout.Diffuse = cout.Diffuse;
+
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/DualTextureEffect.dx11.mgfxo b/MonoGame.Framework/Graphics/Effect/Resources/DualTextureEffect.dx11.mgfxo
new file mode 100644
index 00000000000..b9e6ab5ac79
Binary files /dev/null and b/MonoGame.Framework/Graphics/Effect/Resources/DualTextureEffect.dx11.mgfxo differ
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/DualTextureEffect.fx b/MonoGame.Framework/Graphics/Effect/Resources/DualTextureEffect.fx
new file mode 100644
index 00000000000..515bcf8557f
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/Resources/DualTextureEffect.fx
@@ -0,0 +1,128 @@
+//-----------------------------------------------------------------------------
+// DualTextureEffect.fx
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+#include "Macros.fxh"
+
+
+DECLARE_TEXTURE(Texture, 0);
+DECLARE_TEXTURE(Texture2, 1);
+
+
+BEGIN_CONSTANTS
+
+    float4 DiffuseColor     _vs(c0) _cb(c0);
+    float3 FogColor         _ps(c0) _cb(c1);
+    float4 FogVector        _vs(c5) _cb(c2);
+
+MATRIX_CONSTANTS
+
+    float4x4 WorldViewProj  _vs(c1) _cb(c0);
+
+END_CONSTANTS
+
+
+#include "Structures.fxh"
+#include "Common.fxh"
+
+
+// Vertex shader: basic.
+VSOutputTx2 VSDualTexture(VSInputTx2 vin)
+{
+    VSOutputTx2 vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.TexCoord2 = vin.TexCoord2;
+
+    return vout;
+}
+
+
+// Vertex shader: no fog.
+VSOutputTx2NoFog VSDualTextureNoFog(VSInputTx2 vin)
+{
+    VSOutputTx2NoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.TexCoord2 = vin.TexCoord2;
+
+    return vout;
+}
+
+
+// Vertex shader: vertex color.
+VSOutputTx2 VSDualTextureVc(VSInputTx2Vc vin)
+{
+    VSOutputTx2 vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.TexCoord2 = vin.TexCoord2;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex color, no fog.
+VSOutputTx2NoFog VSDualTextureVcNoFog(VSInputTx2Vc vin)
+{
+    VSOutputTx2NoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.TexCoord2 = vin.TexCoord2;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Pixel shader: basic.
+float4 PSDualTexture(VSOutputTx2 pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord);
+    float4 overlay = SAMPLE_TEXTURE(Texture2, pin.TexCoord2);
+
+    color.rgb *= 2;    
+    color *= overlay * pin.Diffuse;
+    
+    ApplyFog(color, pin.Specular.w);
+    
+    return color;
+}
+
+
+// Pixel shader: no fog.
+float4 PSDualTextureNoFog(VSOutputTx2NoFog pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord);
+    float4 overlay = SAMPLE_TEXTURE(Texture2, pin.TexCoord2);
+    
+    color.rgb *= 2;    
+    color *= overlay * pin.Diffuse;
+    
+    return color;
+}
+
+
+// NOTE: The order of the techniques here are
+// defined to match the indexing in DualTextureEffect.cs.
+
+TECHNIQUE( DualTextureEffect,					VSDualTexture,			PSDualTexture );
+TECHNIQUE( DualTextureEffect_NoFog,				VSDualTextureNoFog,		PSDualTextureNoFog );
+TECHNIQUE( DualTextureEffect_VertexColor,		VSDualTextureVc,		PSDualTexture );
+TECHNIQUE( DualTextureEffect_VertexColor_NoFog,	VSDualTextureVcNoFog,	PSDualTextureNoFog );
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/DualTextureEffect.ogl.mgfxo b/MonoGame.Framework/Graphics/Effect/Resources/DualTextureEffect.ogl.mgfxo
new file mode 100644
index 00000000000..48618169d86
Binary files /dev/null and b/MonoGame.Framework/Graphics/Effect/Resources/DualTextureEffect.ogl.mgfxo differ
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/EnvironmentMapEffect.dx11.mgfxo b/MonoGame.Framework/Graphics/Effect/Resources/EnvironmentMapEffect.dx11.mgfxo
new file mode 100644
index 00000000000..bc07e5885fd
Binary files /dev/null and b/MonoGame.Framework/Graphics/Effect/Resources/EnvironmentMapEffect.dx11.mgfxo differ
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/EnvironmentMapEffect.fx b/MonoGame.Framework/Graphics/Effect/Resources/EnvironmentMapEffect.fx
new file mode 100644
index 00000000000..0fd2ec64fa7
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/Resources/EnvironmentMapEffect.fx
@@ -0,0 +1,196 @@
+//-----------------------------------------------------------------------------
+// EnvironmentMapEffect.fx
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+#include "Macros.fxh"
+
+
+DECLARE_TEXTURE(Texture, 0);
+DECLARE_CUBEMAP(EnvironmentMap, 1);
+
+
+BEGIN_CONSTANTS
+
+    float3 EnvironmentMapSpecular   _ps(c0)  _cb(c0);
+    float  FresnelFactor            _vs(c0)  _cb(c0.w);
+    float  EnvironmentMapAmount     _vs(c1)  _cb(c2.w);
+
+    float4 DiffuseColor             _vs(c2)  _cb(c1);
+    float3 EmissiveColor            _vs(c3)  _cb(c2);
+
+    float3 DirLight0Direction       _vs(c4)  _cb(c3);
+    float3 DirLight0DiffuseColor    _vs(c5)  _cb(c4);
+
+    float3 DirLight1Direction       _vs(c6)  _cb(c5);
+    float3 DirLight1DiffuseColor    _vs(c7)  _cb(c6);
+
+    float3 DirLight2Direction       _vs(c8)  _cb(c7);
+    float3 DirLight2DiffuseColor    _vs(c9)  _cb(c8);
+
+    float3 EyePosition              _vs(c10) _cb(c9);
+
+    float3 FogColor                 _ps(c1)  _cb(c10);
+    float4 FogVector                _vs(c11) _cb(c11);
+
+    float4x4 World                  _vs(c16) _cb(c12);
+    float3x3 WorldInverseTranspose  _vs(c19) _cb(c16);
+
+MATRIX_CONSTANTS
+
+    float4x4 WorldViewProj          _vs(c12) _cb(c0);
+
+END_CONSTANTS
+
+
+// We don't use these parameters, but Lighting.fxh won't compile without them.
+#define SpecularPower           0
+#define SpecularColor           float3(0, 0, 0)
+#define DirLight0SpecularColor  float3(0, 0, 0)
+#define DirLight1SpecularColor  float3(0, 0, 0)
+#define DirLight2SpecularColor  float3(0, 0, 0)
+
+
+#include "Structures.fxh"
+#include "Common.fxh"
+#include "Lighting.fxh"
+
+
+float ComputeFresnelFactor(float3 eyeVector, float3 worldNormal)
+{
+    float viewAngle = dot(eyeVector, worldNormal);
+    
+    return pow(max(1 - abs(viewAngle), 0), FresnelFactor) * EnvironmentMapAmount;
+}
+
+
+VSOutputTxEnvMap ComputeEnvMapVSOutput(VSInputNmTx vin, uniform bool useFresnel, uniform int numLights)
+{
+    VSOutputTxEnvMap vout;
+    
+    float4 pos_ws = mul(vin.Position, World);
+    float3 eyeVector = normalize(EyePosition - pos_ws.xyz);
+    float3 worldNormal = normalize(mul(vin.Normal, WorldInverseTranspose));
+
+    ColorPair lightResult = ComputeLights(eyeVector, worldNormal, numLights);
+    
+    vout.PositionPS = mul(vin.Position, WorldViewProj);
+    vout.Diffuse = float4(lightResult.Diffuse, DiffuseColor.a);
+    
+    if (useFresnel)
+        vout.Specular.rgb = ComputeFresnelFactor(eyeVector, worldNormal);
+    else
+        vout.Specular.rgb = EnvironmentMapAmount;
+    
+    vout.Specular.a = ComputeFogFactor(vin.Position);
+    vout.TexCoord = vin.TexCoord;
+    vout.EnvCoord = reflect(-eyeVector, worldNormal);
+
+    return vout;
+}
+
+
+// Vertex shader: basic.
+VSOutputTxEnvMap VSEnvMap(VSInputNmTx vin)
+{
+    return ComputeEnvMapVSOutput(vin, false, 3);
+}
+
+
+// Vertex shader: fresnel.
+VSOutputTxEnvMap VSEnvMapFresnel(VSInputNmTx vin)
+{
+    return ComputeEnvMapVSOutput(vin, true, 3);
+}
+
+
+// Vertex shader: one light.
+VSOutputTxEnvMap VSEnvMapOneLight(VSInputNmTx vin)
+{
+    return ComputeEnvMapVSOutput(vin, false, 1);
+}
+
+
+// Vertex shader: one light, fresnel.
+VSOutputTxEnvMap VSEnvMapOneLightFresnel(VSInputNmTx vin)
+{
+    return ComputeEnvMapVSOutput(vin, true, 1);
+}
+
+
+// Pixel shader: basic.
+float4 PSEnvMap(VSOutputTxEnvMap pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    float4 envmap = SAMPLE_CUBEMAP(EnvironmentMap, pin.EnvCoord) * color.a;
+
+    color.rgb = lerp(color.rgb, envmap.rgb, pin.Specular.rgb);
+    
+    ApplyFog(color, pin.Specular.w);
+    
+    return color;
+}
+
+
+// Pixel shader: no fog.
+float4 PSEnvMapNoFog(VSOutputTxEnvMap pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    float4 envmap = SAMPLE_CUBEMAP(EnvironmentMap, pin.EnvCoord) * color.a;
+
+    color.rgb = lerp(color.rgb, envmap.rgb, pin.Specular.rgb);
+    
+    return color;
+}
+
+
+// Pixel shader: specular.
+float4 PSEnvMapSpecular(VSOutputTxEnvMap pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    float4 envmap = SAMPLE_CUBEMAP(EnvironmentMap, pin.EnvCoord) * color.a;
+
+    color.rgb = lerp(color.rgb, envmap.rgb, pin.Specular.rgb);
+    color.rgb += EnvironmentMapSpecular * envmap.a;
+    
+    ApplyFog(color, pin.Specular.w);
+    
+    return color;
+}
+
+
+// Pixel shader: specular, no fog.
+float4 PSEnvMapSpecularNoFog(VSOutputTxEnvMap pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    float4 envmap = SAMPLE_CUBEMAP(EnvironmentMap, pin.EnvCoord) * color.a;
+
+    color.rgb = lerp(color.rgb, envmap.rgb, pin.Specular.rgb);
+    color.rgb += EnvironmentMapSpecular * envmap.a;
+    
+    return color;
+}
+
+
+// NOTE: The order of the techniques here are
+// defined to match the indexing in EnvironmentMapEffect.cs.
+
+TECHNIQUE( EnvironmentMapEffect,						VSEnvMap,			PSEnvMap );
+TECHNIQUE( EnvironmentMapEffect_NoFog,					VSEnvMap,			PSEnvMapNoFog );
+TECHNIQUE( EnvironmentMapEffect_Fresnel,				VSEnvMapFresnel,	PSEnvMap );
+TECHNIQUE( EnvironmentMapEffect_Fresnel_NoFog,			VSEnvMapFresnel,	PSEnvMapNoFog );
+TECHNIQUE( EnvironmentMapEffect_Specular,				VSEnvMap,			PSEnvMapSpecular );
+TECHNIQUE( EnvironmentMapEffect_Specular_NoFog,			VSEnvMap,			PSEnvMapSpecularNoFog );
+TECHNIQUE( EnvironmentMapEffect_Fresnel_Specular,		VSEnvMapFresnel,	PSEnvMapSpecular );
+TECHNIQUE( EnvironmentMapEffect_Fresnel_Specular_NoFog,	VSEnvMapFresnel,	PSEnvMapSpecularNoFog );
+
+TECHNIQUE( EnvironmentMapEffect_OneLight,							VSEnvMapOneLight,			PSEnvMap );
+TECHNIQUE( EnvironmentMapEffect_OneLight_NoFog,						VSEnvMapOneLight,			PSEnvMapNoFog );
+TECHNIQUE( EnvironmentMapEffect_OneLight_Fresnel,					VSEnvMapOneLightFresnel,	PSEnvMap );
+TECHNIQUE( EnvironmentMapEffect_OneLight_Fresnel_NoFog,				VSEnvMapOneLightFresnel,	PSEnvMapNoFog );
+TECHNIQUE( EnvironmentMapEffect_OneLight_Specular,					VSEnvMapOneLight,			PSEnvMapSpecular );
+TECHNIQUE( EnvironmentMapEffect_OneLight_Specular_NoFog,			VSEnvMapOneLight,			PSEnvMapSpecularNoFog );
+TECHNIQUE( EnvironmentMapEffect_OneLight_Fresnel_Specular,			VSEnvMapOneLightFresnel,	PSEnvMapSpecular );
+TECHNIQUE( EnvironmentMapEffect_OneLight_Fresnel_Specular_NoFog,	VSEnvMapOneLightFresnel,	PSEnvMapSpecularNoFog );
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/EnvironmentMapEffect.ogl.mgfxo b/MonoGame.Framework/Graphics/Effect/Resources/EnvironmentMapEffect.ogl.mgfxo
new file mode 100644
index 00000000000..4b4ea60814a
Binary files /dev/null and b/MonoGame.Framework/Graphics/Effect/Resources/EnvironmentMapEffect.ogl.mgfxo differ
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/Lighting.fxh b/MonoGame.Framework/Graphics/Effect/Resources/Lighting.fxh
new file mode 100644
index 00000000000..6b82db49dd1
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/Resources/Lighting.fxh
@@ -0,0 +1,94 @@
+//-----------------------------------------------------------------------------
+// Lighting.fxh
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+
+struct ColorPair
+{
+    float3 Diffuse;
+    float3 Specular;
+};
+
+
+ColorPair ComputeLights(float3 eyeVector, float3 worldNormal, uniform int numLights)
+{
+    float3x3 lightDirections = 0;
+    float3x3 lightDiffuse = 0;
+    float3x3 lightSpecular = 0;
+    float3x3 halfVectors = 0;
+    
+    [unroll]
+    for (int i = 0; i < numLights; i++)
+    {
+        lightDirections[i] = float3x3(DirLight0Direction,     DirLight1Direction,     DirLight2Direction)    [i];
+        lightDiffuse[i]    = float3x3(DirLight0DiffuseColor,  DirLight1DiffuseColor,  DirLight2DiffuseColor) [i];
+        lightSpecular[i]   = float3x3(DirLight0SpecularColor, DirLight1SpecularColor, DirLight2SpecularColor)[i];
+        
+        halfVectors[i] = normalize(eyeVector - lightDirections[i]);
+    }
+
+    float3 dotL = mul(-lightDirections, worldNormal);
+    float3 dotH = mul(halfVectors, worldNormal);
+    
+    float3 zeroL = step(float3(0,0,0), dotL);
+
+    float3 diffuse  = zeroL * dotL;
+    float3 specular = pow(max(dotH, 0) * zeroL, SpecularPower);
+
+    ColorPair result;
+    
+    result.Diffuse  = mul(diffuse,  lightDiffuse)  * DiffuseColor.rgb + EmissiveColor;
+    result.Specular = mul(specular, lightSpecular) * SpecularColor;
+
+    return result;
+}
+
+
+CommonVSOutput ComputeCommonVSOutputWithLighting(float4 position, float3 normal, uniform int numLights)
+{
+    CommonVSOutput vout;
+    
+    float4 pos_ws = mul(position, World);
+    float3 eyeVector = normalize(EyePosition - pos_ws.xyz);
+    float3 worldNormal = normalize(mul(normal, WorldInverseTranspose));
+
+    ColorPair lightResult = ComputeLights(eyeVector, worldNormal, numLights);
+    
+    vout.Pos_ps = mul(position, WorldViewProj);
+    vout.Diffuse = float4(lightResult.Diffuse, DiffuseColor.a);
+    vout.Specular = lightResult.Specular;
+    vout.FogFactor = ComputeFogFactor(position);
+    
+    return vout;
+}
+
+
+struct CommonVSOutputPixelLighting
+{
+    float4 Pos_ps;
+    float3 Pos_ws;
+    float3 Normal_ws;
+    float  FogFactor;
+};
+
+
+CommonVSOutputPixelLighting ComputeCommonVSOutputPixelLighting(float4 position, float3 normal)
+{
+    CommonVSOutputPixelLighting vout;
+    
+    vout.Pos_ps = mul(position, WorldViewProj);
+    vout.Pos_ws = mul(position, World).xyz;
+    vout.Normal_ws = normalize(mul(normal, WorldInverseTranspose));
+    vout.FogFactor = ComputeFogFactor(position);
+    
+    return vout;
+}
+
+
+#define SetCommonVSOutputParamsPixelLighting \
+    vout.PositionPS = cout.Pos_ps; \
+    vout.PositionWS = float4(cout.Pos_ws, cout.FogFactor); \
+    vout.NormalWS = cout.Normal_ws;
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/Macros.fxh b/MonoGame.Framework/Graphics/Effect/Resources/Macros.fxh
new file mode 100644
index 00000000000..7b1d31e05f6
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/Resources/Macros.fxh
@@ -0,0 +1,61 @@
+//-----------------------------------------------------------------------------
+// Macros.fxh
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+#ifdef 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
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/Microsoft_Permissive_License.rtf b/MonoGame.Framework/Graphics/Effect/Resources/Microsoft_Permissive_License.rtf
new file mode 100644
index 00000000000..a88280ab95c
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/Resources/Microsoft_Permissive_License.rtf
@@ -0,0 +1,230 @@
+{\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff1\deff0\stshfdbch0\stshfloch0\stshfhich0\stshfbi0\deflang1033\deflangfe1033\themelang1033\themelangfe0\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f1\fbidi \fswiss\fcharset0\fprq2{\*\panose 020b0604020202020204}Arial;}
+{\f34\fbidi \froman\fcharset1\fprq2{\*\panose 02040503050406030204}Cambria Math;}{\f36\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria;}{\f38\fbidi \fswiss\fcharset0\fprq2{\*\panose 020b0604030504040204}Tahoma;}
+{\f40\fbidi \fswiss\fcharset0\fprq2{\*\panose 020b0604030504040204}Verdana;}{\flomajor\f31500\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
+{\fdbmajor\f31501\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhimajor\f31502\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria;}
+{\fbimajor\f31503\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\flominor\f31504\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}
+{\fdbminor\f31505\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhiminor\f31506\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}
+{\fbiminor\f31507\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f41\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\f42\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
+{\f44\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\f45\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\f46\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\f47\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
+{\f48\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\f49\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\f51\fbidi \fswiss\fcharset238\fprq2 Arial CE;}{\f52\fbidi \fswiss\fcharset204\fprq2 Arial Cyr;}
+{\f54\fbidi \fswiss\fcharset161\fprq2 Arial Greek;}{\f55\fbidi \fswiss\fcharset162\fprq2 Arial Tur;}{\f56\fbidi \fswiss\fcharset177\fprq2 Arial (Hebrew);}{\f57\fbidi \fswiss\fcharset178\fprq2 Arial (Arabic);}
+{\f58\fbidi \fswiss\fcharset186\fprq2 Arial Baltic;}{\f59\fbidi \fswiss\fcharset163\fprq2 Arial (Vietnamese);}{\f401\fbidi \froman\fcharset238\fprq2 Cambria CE;}{\f402\fbidi \froman\fcharset204\fprq2 Cambria Cyr;}
+{\f404\fbidi \froman\fcharset161\fprq2 Cambria Greek;}{\f405\fbidi \froman\fcharset162\fprq2 Cambria Tur;}{\f408\fbidi \froman\fcharset186\fprq2 Cambria Baltic;}{\f421\fbidi \fswiss\fcharset238\fprq2 Tahoma CE;}
+{\f422\fbidi \fswiss\fcharset204\fprq2 Tahoma Cyr;}{\f424\fbidi \fswiss\fcharset161\fprq2 Tahoma Greek;}{\f425\fbidi \fswiss\fcharset162\fprq2 Tahoma Tur;}{\f426\fbidi \fswiss\fcharset177\fprq2 Tahoma (Hebrew);}
+{\f427\fbidi \fswiss\fcharset178\fprq2 Tahoma (Arabic);}{\f428\fbidi \fswiss\fcharset186\fprq2 Tahoma Baltic;}{\f429\fbidi \fswiss\fcharset163\fprq2 Tahoma (Vietnamese);}{\f430\fbidi \fswiss\fcharset222\fprq2 Tahoma (Thai);}
+{\f441\fbidi \fswiss\fcharset238\fprq2 Verdana CE;}{\f442\fbidi \fswiss\fcharset204\fprq2 Verdana Cyr;}{\f444\fbidi \fswiss\fcharset161\fprq2 Verdana Greek;}{\f445\fbidi \fswiss\fcharset162\fprq2 Verdana Tur;}
+{\f448\fbidi \fswiss\fcharset186\fprq2 Verdana Baltic;}{\f449\fbidi \fswiss\fcharset163\fprq2 Verdana (Vietnamese);}{\flomajor\f31508\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
+{\flomajor\f31509\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flomajor\f31511\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flomajor\f31512\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}
+{\flomajor\f31513\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flomajor\f31514\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flomajor\f31515\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}
+{\flomajor\f31516\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbmajor\f31518\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fdbmajor\f31519\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
+{\fdbmajor\f31521\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbmajor\f31522\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fdbmajor\f31523\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
+{\fdbmajor\f31524\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbmajor\f31525\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fdbmajor\f31526\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}
+{\fhimajor\f31528\fbidi \froman\fcharset238\fprq2 Cambria CE;}{\fhimajor\f31529\fbidi \froman\fcharset204\fprq2 Cambria Cyr;}{\fhimajor\f31531\fbidi \froman\fcharset161\fprq2 Cambria Greek;}{\fhimajor\f31532\fbidi \froman\fcharset162\fprq2 Cambria Tur;}
+{\fhimajor\f31535\fbidi \froman\fcharset186\fprq2 Cambria Baltic;}{\fbimajor\f31538\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fbimajor\f31539\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}
+{\fbimajor\f31541\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbimajor\f31542\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fbimajor\f31543\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}
+{\fbimajor\f31544\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbimajor\f31545\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fbimajor\f31546\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}
+{\flominor\f31548\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flominor\f31549\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flominor\f31551\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}
+{\flominor\f31552\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flominor\f31553\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flominor\f31554\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
+{\flominor\f31555\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flominor\f31556\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbminor\f31558\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}
+{\fdbminor\f31559\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbminor\f31561\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbminor\f31562\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}
+{\fdbminor\f31563\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbminor\f31564\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbminor\f31565\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}
+{\fdbminor\f31566\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhiminor\f31568\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\fhiminor\f31569\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}
+{\fhiminor\f31571\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\fhiminor\f31572\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;}{\fhiminor\f31575\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}
+{\fbiminor\f31578\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fbiminor\f31579\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fbiminor\f31581\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}
+{\fbiminor\f31582\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fbiminor\f31583\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fbiminor\f31584\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}
+{\fbiminor\f31585\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fbiminor\f31586\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}}{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;
+\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;
+\red192\green192\blue192;}{\*\defchp }{\*\defpap \ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 }\noqfpromote {\stylesheet{\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 
+\ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \snext0 \sqformat \spriority0 Normal;}{\s1\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\outlinelevel0\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 
+\f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext0 \slink15 \sqformat \spriority9 heading 1;}{\s2\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 
+\f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext0 \slink16 \sqformat \spriority9 heading 2;}{\*\cs10 \additive \ssemihidden Default Paragraph Font;}{\*
+\ts11\tsrowd\trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\trcbpat1\trcfpat1\tblind0\tblindtype3\tscellwidthfts0\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv 
+\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs20\alang1025 \ltrch\fcs0 \fs20\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \snext11 \ssemihidden \sunhideused \sqformat Normal Table;}{\*\cs15 
+\additive \rtlch\fcs1 \ab\af0\afs32 \ltrch\fcs0 \b\f36\fs32\kerning32 \sbasedon10 \slink1 \slocked \spriority9 Heading 1 Char;}{\*\cs16 \additive \rtlch\fcs1 \ab\ai\af0\afs28 \ltrch\fcs0 \b\i\f36\fs28 \sbasedon10 \slink2 \slocked \spriority9 
+Heading 2 Char;}{\s17\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af38\afs16\alang1025 \ltrch\fcs0 \f38\fs16\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 
+\sbasedon0 \snext17 \slink18 \ssemihidden \sunhideused \styrsid7424395 Balloon Text;}{\*\cs18 \additive \rtlch\fcs1 \af38\afs16 \ltrch\fcs0 \f38\fs16 \sbasedon10 \slink17 \slocked \ssemihidden \styrsid7424395 Balloon Text Char;}{\*\cs19 \additive 
+\rtlch\fcs1 \af0\afs16 \ltrch\fcs0 \fs16 \sbasedon10 \ssemihidden \sunhideused \styrsid4538388 annotation reference;}{\s20\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs20\alang1025 \ltrch\fcs0 
+\f1\fs20\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext20 \slink21 \ssemihidden \sunhideused \styrsid4538388 annotation text;}{\*\cs21 \additive \rtlch\fcs1 \af1 \ltrch\fcs0 \f1 
+\sbasedon10 \slink20 \slocked \ssemihidden \styrsid4538388 Comment Text Char;}{\s22\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \ab\af1\afs20\alang1025 \ltrch\fcs0 \b\f1\fs20\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 
+\sbasedon20 \snext20 \slink23 \ssemihidden \sunhideused \styrsid4538388 annotation subject;}{\*\cs23 \additive \rtlch\fcs1 \ab\af1 \ltrch\fcs0 \b\f1 \sbasedon21 \slink22 \slocked \ssemihidden \styrsid4538388 Comment Subject Char;}}{\*\rsidtbl \rsid213160
+\rsid284417\rsid417145\rsid481196\rsid551334\rsid723397\rsid786968\rsid1382437\rsid1390003\rsid1521043\rsid1530955\rsid1708989\rsid1783212\rsid1903779\rsid2431884\rsid3165084\rsid3416120\rsid3419781\rsid3754103\rsid3768194\rsid3831520\rsid4538130
+\rsid4538388\rsid4552277\rsid4680449\rsid4729674\rsid4865270\rsid4987534\rsid5128131\rsid5186068\rsid5864350\rsid6186044\rsid6311778\rsid6384507\rsid6434687\rsid6561471\rsid6910344\rsid6947552\rsid7033180\rsid7424395\rsid7682010\rsid7690850\rsid7744081
+\rsid8151618\rsid8196281\rsid8198206\rsid8342723\rsid8350925\rsid8722561\rsid8852349\rsid8934457\rsid8944153\rsid9573035\rsid9635349\rsid9638545\rsid9724918\rsid10044820\rsid10095979\rsid10228618\rsid10449644\rsid10494075\rsid11166278\rsid11166751
+\rsid11285353\rsid11366513\rsid11494815\rsid11932529\rsid12061202\rsid12533699\rsid12536400\rsid12916885\rsid13264736\rsid13322831\rsid13440556\rsid13455614\rsid13597357\rsid13768671\rsid14097590\rsid14157399\rsid14229900\rsid14305025\rsid14314735
+\rsid14436896\rsid14565916\rsid14572556\rsid14688892\rsid14752433\rsid14904394\rsid15086147\rsid15749945\rsid15814398\rsid15927751\rsid16071312\rsid16126175\rsid16279402\rsid16391569\rsid16404661\rsid16452939\rsid16537688\rsid16606866\rsid16674896}
+{\mmathPr\mmathFont34\mbrkBin0\mbrkBinSub0\msmallFrac0\mdispDef1\mlMargin0\mrMargin0\mdefJc1\mwrapIndent1440\mintLim0\mnaryLim1}{\info{\title Microsoft Permissive License (Ms-PL)}{\author Jonr}{\operator Dean Johnson}{\creatim\yr2007\mo2\dy23\hr15\min10}
+{\revtim\yr2007\mo2\dy23\hr15\min10}{\printim\yr2006\mo9\dy28\hr8\min46}{\version2}{\edmins1}{\nofpages1}{\nofwords404}{\nofchars2221}{\*\company Microsoft}{\nofcharsws2620}{\vern32859}{\*\saveprevpict}}{\*\userprops {\propname _NewReviewCycle}\proptype30
+{\staticval }}{\*\xmlnstbl {\xmlns1 http://schemas.microsoft.com/office/word/2003/wordml}{\xmlns2 urn:schemas-microsoft-com:office:smarttags}}\paperw12240\paperh15840\margl1440\margr1440\margt1440\margb1440\gutter0\ltrsect 
+\widowctrl\ftnbj\aenddoc\trackmoves0\trackformatting1\donotembedsysfont0\relyonvml0\donotembedlingdata1\grfdocevents0\validatexml0\showplaceholdtext0\ignoremixedcontent0\saveinvalidxml0\showxmlerrors0\hyphcaps0\horzdoc\dghspace120\dgvspace120
+\dghorigin1701\dgvorigin1984\dghshow0\dgvshow3\jcompress\viewkind1\viewscale100\splytwnine\ftnlytwnine\htmautsp\useltbaln\alntblind\lytcalctblwd\lyttblrtgr\lnbrkrule\nobrkwrptbl\snaptogridincell\allowfieldendsel\wrppunct\asianbrkrule\rsidroot10494075
+\newtblstyruls\nogrowautofit\utinl \fet0{\*\wgrffmtfilter 2450}\ilfomacatclnup0\ltrpar \sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl2\pnucltr\pnstart1\pnindent720\pnhang {\pntxta .}}
+{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta )}}{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl6\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}
+{\pntxta )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl8\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl9\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}\pard\plain \ltrpar
+\s1\ql \li0\ri0\sb180\nowidctlpar\wrapdefault\faauto\outlinelevel0\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af1\afs31 \ltrch\fcs0 
+\fs31\cf1\kerning36\insrsid10494075\charrsid14688892 Microsoft}{\rtlch\fcs1 \af1\afs31 \ltrch\fcs0 \fs31\cf1\kerning36\insrsid10494075  Permissive}{\rtlch\fcs1 \af1\afs31 \ltrch\fcs0 \fs31\cf1\kerning36\insrsid14688892  }{\rtlch\fcs1 \af1\afs31 
+\ltrch\fcs0 \fs31\cf1\kerning36\insrsid10494075 License (Ms-PL}{\rtlch\fcs1 \af1\afs31 \ltrch\fcs0 \fs31\cf1\kerning36\insrsid4552277 )}{\rtlch\fcs1 \af1\afs31 \ltrch\fcs0 \fs31\cf1\kerning36\insrsid10494075 
+\par }\pard\plain \ltrpar\ql \li0\ri0\sl336\slmult1\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af40\afs17 \ltrch\fcs0 
+\b\f40\fs17\insrsid10494075 
+\par This license governs use of the accompanying software. If you use the software, you accept this license. If you do not accept the license, do not use the software.
+\par }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid6910344 
+\par }\pard\plain \ltrpar\s2\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af40\afs23 \ltrch\fcs0 
+\b\f40\fs23\insrsid10494075 1. Definitions
+\par }\pard\plain \ltrpar\ql \li0\ri0\sl336\slmult1\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 
+\f40\fs17\insrsid10494075 The terms \'93reproduce,\'94 \'93reproduction}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid7744081 ,}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 \'94 }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 
+\f40\fs17\insrsid551334 \'93derivative works,\'94}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid7744081\charrsid7744081  }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 and \'93distribution\'94 have the same meaning here as under 
+{\*\xmlopen\xmlns2{\factoidname country-region}}{\*\xmlopen\xmlns2{\factoidname place}}U.S.{\*\xmlclose}{\*\xmlclose} copyright law.
+\par }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid12536400 A \'93contribution\'94 is the original software}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid4865270 ,}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid12536400  }{\rtlch\fcs1 
+\af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid11932529 or}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid12536400  any additions or changes to the software.
+\par }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid551334 A \'93c}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid551334\charrsid551334 ontributor\'94 }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid12536400 is}{\rtlch\fcs1 \af40\afs17 
+\ltrch\fcs0 \f40\fs17\insrsid12536400\charrsid551334  }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid551334\charrsid551334 any person that }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid12536400 
+distributes its contribution under this license.}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 
+\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid14229900 {\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid4729674\delrsid4729674  }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 \'93Licensed patents
+\'94 }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid12536400 are }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid3831520 a contributor\rquote s }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 patent claims }{\rtlch\fcs1 
+\af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid3831520 that }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 read directly on }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid3831520 its contribution.}{\rtlch\fcs1 \af1 \ltrch\fcs0 
+\insrsid14229900\charrsid14229900 
+\par }\pard\plain \ltrpar\s2\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af40\afs23 \ltrch\fcs0 
+\b\f40\fs23\insrsid5186068 
+\par }{\rtlch\fcs1 \ab\af40\afs23 \ltrch\fcs0 \b\f40\fs23\insrsid10494075 2. Grant of Rights
+\par }\pard\plain \ltrpar\ql \li0\ri0\sl336\slmult1\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 
+\f40\fs17\insrsid10494075 (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid3754103 each contributor }{\rtlch\fcs1 \af40\afs17 
+\ltrch\fcs0 \f40\fs17\insrsid10494075 grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid3754103 its contribution}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 
+\f40\fs17\insrsid10494075 , prepare derivative works of }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid3754103 its contribution}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid12536400 ,}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 
+\f40\fs17\insrsid10494075  and distribute }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid3754103 its contribution}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075  or any derivative works that you create.
+\par (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid9724918 each contributor }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 
+\f40\fs17\insrsid10494075 grants you a non-exclusive, worldwide, royalty-free license under }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid15814398 its }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 licensed patents
+ to make, have made, use, sell, offer for sale, }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid1390003 import, }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 and/or otherwise dispose of }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 
+\f40\fs17\insrsid8944153 its contribution in }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 the software or derivative works of }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid8944153 the contribution in }{\rtlch\fcs1 \af40\afs17 
+\ltrch\fcs0 \f40\fs17\insrsid10494075 the software.
+\par }\pard\plain \ltrpar\s2\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af40\afs23 \ltrch\fcs0 
+\b\f40\fs23\insrsid5186068 
+\par }{\rtlch\fcs1 \ab\af40\afs23 \ltrch\fcs0 \b\f40\fs23\insrsid10494075 3. Conditions and Limitations
+\par }\pard\plain \ltrpar\ql \li0\ri0\sl336\slmult1\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af1\afs24\alang1025 \ltrch\fcs0 \f1\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 
+\f40\fs17\insrsid1530955  }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 (A) No Trademark License- This license does not grant you rights to use }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid1708989 any contributors\rquote  }{
+\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 name, logo, or trademarks.
+\par (B) If you }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid8934457 bring a patent claim against }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10095979 any contributor}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 
+ over patents that you }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid6947552 claim }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid7682010 are }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid6947552 infringe}{\rtlch\fcs1 
+\af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid7682010 d by}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075  the software, your }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid7682010 patent }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 
+\f40\fs17\insrsid10494075 license}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid7682010  from such contributor}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075  to the software ends automatically.
+\par (C) If you distribute }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid3165084 any portion of }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 
+the software, you must retain all copyright, patent, trademark, and attribution notices that are present in the software.
+\par (D) If you distribute }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid15749945 any portion of the }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 software in source code form}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 
+\f40\fs17\insrsid14904394 ,}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075  you may do so only under this license}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid6384507  }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 
+\f40\fs17\insrsid14904394 by including }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 a complete copy of this license with your distribution}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid6384507 .}{\rtlch\fcs1 \af40\afs17 
+\ltrch\fcs0 \f40\fs17\insrsid10494075  }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid6384507 I}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 f you distribute }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid15749945 
+any portion of }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 the software in compiled or object code form}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid16452939 ,}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 
+ you may only do so under a license that complies with this license.
+\par }\pard \ltrpar\ql \li0\ri0\sl336\slmult1\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid14572556 {\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 (E) The software is licensed \'93as-is.\'94 You bear the risk of using it. }{
+\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid284417 The contributors }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 
+give no express warranties, guarantees or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent permitted under your local laws, }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 
+\f40\fs17\insrsid1783212 the contributors }{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 \f40\fs17\insrsid10494075 exclude the implied warranties of merchantability, fitness for a particular purpose and non-infringement.}{\rtlch\fcs1 \af40\afs17 \ltrch\fcs0 
+\f40\fs17\insrsid10494075\charrsid14572556 
+\par }{\*\themedata 504b030414000600080000002100828abc13fa0000001c020000130000005b436f6e74656e745f54797065735d2e786d6cac91cb6ac3301045f785fe83d0b6d8
+72ba28a5d8cea249777d2cd20f18e4b12d6a8f843409c9df77ecb850ba082d74231062ce997b55ae8fe3a00e1893f354e9555e6885647de3a8abf4fbee29bbd7
+2a3150038327acf409935ed7d757e5ee14302999a654e99e393c18936c8f23a4dc072479697d1c81e51a3b13c07e4087e6b628ee8cf5c4489cf1c4d075f92a0b
+44d7a07a83c82f308ac7b0a0f0fbf90c2480980b58abc733615aa2d210c2e02cb04430076a7ee833dfb6ce62e3ed7e14693e8317d8cd0433bf5c60f53fea2fe7
+065bd80facb647e9e25c7fc421fd2ddb526b2e9373fed4bb902e182e97b7b461e6bfad3f010000ffff0300504b030414000600080000002100a5d6a7e7c00000
+00360100000b0000005f72656c732f2e72656c73848fcf6ac3300c87ef85bd83d17d51d2c31825762fa590432fa37d00e1287f68221bdb1bebdb4fc7060abb08
+84a4eff7a93dfeae8bf9e194e720169aaa06c3e2433fcb68e1763dbf7f82c985a4a725085b787086a37bdbb55fbc50d1a33ccd311ba548b63095120f88d94fbc
+52ae4264d1c910d24a45db3462247fa791715fd71f989e19e0364cd3f51652d73760ae8fa8c9ffb3c330cc9e4fc17faf2ce545046e37944c69e462a1a82fe353
+bd90a865aad41ed0b5b8f9d6fd010000ffff0300504b0304140006000800000021006b799616830000008a0000001c0000007468656d652f7468656d652f7468
+656d654d616e616765722e786d6c0ccc4d0ac3201040e17da17790d93763bb284562b2cbaebbf600439c1a41c7a0d29fdbd7e5e38337cedf14d59b4b0d592c9c
+070d8a65cd2e88b7f07c2ca71ba8da481cc52c6ce1c715e6e97818c9b48d13df49c873517d23d59085adb5dd20d6b52bd521ef2cdd5eb9246a3d8b4757e8d3f7
+29e245eb2b260a0238fd010000ffff0300504b03041400060008000000210096b5ade296060000501b0000160000007468656d652f7468656d652f7468656d65
+312e786d6cec594f6fdb3614bf0fd87720746f6327761a07758ad8b19b2d4d1bc46e871e698996d850a240d2497d1bdae38001c3ba618715d86d87615b8116d8
+a5fb34d93a6c1dd0afb0475292c5585e9236d88aad3e2412f9e3fbff1e1fa9abd7eec70c1d1221294fda5efd72cd4324f1794093b0eddd1ef62fad79482a9c04
+98f184b4bd2991deb58df7dfbb8ad755446282607d22d771db8b944ad79796a40fc3585ee62949606ecc458c15bc8a702910f808e8c66c69b9565b5d8a314d3c
+94e018c8de1a8fa94fd05093f43672e23d06af89927ac06762a049136785c10607758d9053d965021d62d6f6804fc08f86e4bef210c352c144dbab999fb7b471
+7509af678b985ab0b6b4ae6f7ed9ba6c4170b06c788a705430adf71bad2b5b057d03606a1ed7ebf5babd7a41cf00b0ef83a6569632cd467faddec9699640f671
+9e76b7d6ac355c7c89feca9cccad4ea7d36c65b258a206641f1b73f8b5da6a6373d9c11b90c537e7f08dce66b7bbeae00dc8e257e7f0fd2badd5868b37a088d1
+e4600ead1ddaef67d40bc898b3ed4af81ac0d76a197c86826828a24bb318f3442d8ab518dfe3a20f000d6458d104a9694ac6d88728eee2782428d60cf03ac1a5
+193be4cbb921cd0b495fd054b5bd0f530c1931a3f7eaf9f7af9e3f45c70f9e1d3ff8e9f8e1c3e3073f5a42ceaa6d9c84e5552fbffdeccfc71fa33f9e7ef3f2d1
+17d57859c6fffac327bffcfc793510d26726ce8b2f9ffcf6ecc98baf3efdfdbb4715f04d814765f890c644a29be408edf3181433567125272371be15c308d3f2
+8acd249438c19a4b05fd9e8a1cf4cd296699771c393ac4b5e01d01e5a30a787d72cf1178108989a2159c77a2d801ee72ce3a5c545a6147f32a99793849c26ae6
+6252c6ed637c58c5bb8b13c7bfbd490a75330f4b47f16e441c31f7184e140e494214d273fc80900aedee52ead87597fa824b3e56e82e451d4c2b4d32a423279a
+668bb6690c7e9956e90cfe766cb37b077538abd27a8b1cba48c80acc2a841f12e698f13a9e281c57911ce298950d7e03aba84ac8c154f8655c4f2af074481847
+bd804859b5e696007d4b4edfc150b12addbecba6b18b148a1e54d1bc81392f23b7f84137c2715a851dd0242a633f900710a218ed715505dfe56e86e877f0034e
+16bafb0e258ebb4faf06b769e888340b103d3311da9750aa9d0a1cd3e4efca31a3508f6d0c5c5c398602f8e2ebc71591f5b616e24dd893aa3261fb44f95d843b
+5974bb5c04f4edafb95b7892ec1108f3f98de75dc97d5772bdff7cc95d94cf672db4b3da0a6557f70db629362d72bcb0431e53c6066acac80d699a6409fb44d0
+8741bdce9c0e4971624a2378cceaba830b05366b90e0ea23aaa241845368b0eb9e2612ca8c742851ca251ceccc70256d8d87265dd96361531f186c3d9058edf2
+c00eafe8e1fc5c509031bb4d680e9f39a3154de0accc56ae644441edd76156d7429d995bdd88664a9dc3ad50197c38af1a0c16d684060441db02565e85f3b966
+0d0713cc48a0ed6ef7dedc2dc60b17e92219e180643ed27acffba86e9c94c78ab90980d8a9f0913ee49d62b512b79626fb06dccee2a432bbc60276b9f7dec44b
+7904cfbca4f3f6443ab2a49c9c2c41476dafd55c6e7ac8c769db1bc399161ee314bc2e75cf8759081743be1236ec4f4d6693e5336fb672c5dc24a8c33585b5fb
+9cc24e1d4885545b58463634cc5416022cd19cacfccb4d30eb45296023fd35a458598360f8d7a4003bbaae25e331f155d9d9a5116d3bfb9a95523e51440ca2e0
+088dd844ec6370bf0e55d027a012ae264c45d02f708fa6ad6da6dce29c255df9f6cae0ec38666984b372ab5334cf640b37795cc860de4ae2816e95b21be5ceaf
+8a49f90b52a51cc6ff3355f47e0237052b81f6800fd7b802239daf6d8f0b1571a8426944fdbe80c6c1d40e8816b88b8569082ab84c36ff0539d4ff6dce591a26
+ade1c0a7f669880485fd484582903d284b26fa4e2156cff62e4b9265844c4495c495a9157b440e091bea1ab8aaf7760f4510eaa69a6465c0e04ec69ffb9e65d0
+28d44d4e39df9c1a52ecbd3607fee9cec7263328e5d661d3d0e4f62f44acd855ed7ab33cdf7bcb8ae889599bd5c8b3029895b6825696f6af29c239b75a5bb1e6
+345e6ee6c28117e73586c1a2214ae1be07e93fb0ff51e133fb65426fa843be0fb515c187064d0cc206a2fa926d3c902e907670048d931db4c1a44959d366ad93
+b65abe595f70a75bf03d616c2dd959fc7d4e6317cd99cbcec9c58b34766661c7d6766ca1a9c1b327531486c6f941c638c67cd22a7f75e2a37be0e82db8df9f30
+254d30c1372581a1f51c983c80e4b71ccdd28dbf000000ffff0300504b0304140006000800000021000dd1909fb60000001b010000270000007468656d652f74
+68656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73848f4d0ac2301484f78277086f6fd3ba109126dd88d0add40384e4350d363f24
+51eced0dae2c082e8761be9969bb979dc9136332de3168aa1a083ae995719ac16db8ec8e4052164e89d93b64b060828e6f37ed1567914b284d262452282e3198
+720e274a939cd08a54f980ae38a38f56e422a3a641c8bbd048f7757da0f19b017cc524bd62107bd5001996509affb3fd381a89672f1f165dfe514173d9850528
+a2c6cce0239baa4c04ca5bbabac4df000000ffff0300504b01022d0014000600080000002100828abc13fa0000001c0200001300000000000000000000000000
+000000005b436f6e74656e745f54797065735d2e786d6c504b01022d0014000600080000002100a5d6a7e7c0000000360100000b000000000000000000000000
+002b0100005f72656c732f2e72656c73504b01022d00140006000800000021006b799616830000008a0000001c00000000000000000000000000140200007468
+656d652f7468656d652f7468656d654d616e616765722e786d6c504b01022d001400060008000000210096b5ade296060000501b000016000000000000000000
+00000000d10200007468656d652f7468656d652f7468656d65312e786d6c504b01022d00140006000800000021000dd1909fb60000001b010000270000000000
+00000000000000009b0900007468656d652f7468656d652f5f72656c732f7468656d654d616e616765722e786d6c2e72656c73504b050600000000050005005d010000960a00000000}
+{\*\colorschememapping 3c3f786d6c2076657273696f6e3d22312e302220656e636f64696e673d225554462d3822207374616e64616c6f6e653d22796573223f3e0d0a3c613a636c724d
+617020786d6c6e733a613d22687474703a2f2f736368656d61732e6f70656e786d6c666f726d6174732e6f72672f64726177696e676d6c2f323030362f6d6169
+6e22206267313d226c743122207478313d22646b3122206267323d226c743222207478323d22646b322220616363656e74313d22616363656e74312220616363
+656e74323d22616363656e74322220616363656e74333d22616363656e74332220616363656e74343d22616363656e74342220616363656e74353d22616363656e74352220616363656e74363d22616363656e74362220686c696e6b3d22686c696e6b2220666f6c486c696e6b3d22666f6c486c696e6b222f3e}
+{\*\latentstyles\lsdstimax267\lsdlockeddef0\lsdsemihiddendef1\lsdunhideuseddef1\lsdqformatdef0\lsdprioritydef99{\lsdlockedexcept \lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority0 \lsdlocked0 Normal;
+\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 1;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority9 \lsdlocked0 heading 2;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 3;
+\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 4;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 5;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 6;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 7;\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 8;
+\lsdqformat1 \lsdpriority9 \lsdlocked0 heading 9;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 1;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 2;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 3;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 4;
+\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 5;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 6;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 7;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 8;\lsdqformat1 \lsdpriority39 \lsdlocked0 toc 9;
+\lsdqformat1 \lsdpriority35 \lsdlocked0 caption;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority10 \lsdlocked0 Title;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority11 \lsdlocked0 Subtitle;
+\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority22 \lsdlocked0 Strong;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority20 \lsdlocked0 Emphasis;\lsdsemihidden0 \lsdunhideused0 \lsdpriority59 \lsdlocked0 Table Grid;
+\lsdunhideused0 \lsdlocked0 Placeholder Text;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority1 \lsdlocked0 No Spacing;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 1;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 1;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 1;\lsdunhideused0 \lsdlocked0 Revision;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority34 \lsdlocked0 List Paragraph;
+\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority29 \lsdlocked0 Quote;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority30 \lsdlocked0 Intense Quote;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 1;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 1;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 1;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 1;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 2;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 2;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 2;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 2;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 2;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 2;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 3;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 3;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 3;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 3;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 3;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 4;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 4;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 4;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 4;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 4;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 4;\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 5;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 5;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 5;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 5;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 5;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 5;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority60 \lsdlocked0 Light Shading Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority61 \lsdlocked0 Light List Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority62 \lsdlocked0 Light Grid Accent 6;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority63 \lsdlocked0 Medium Shading 1 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority64 \lsdlocked0 Medium Shading 2 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority65 \lsdlocked0 Medium List 1 Accent 6;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority66 \lsdlocked0 Medium List 2 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority67 \lsdlocked0 Medium Grid 1 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority68 \lsdlocked0 Medium Grid 2 Accent 6;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority69 \lsdlocked0 Medium Grid 3 Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority70 \lsdlocked0 Dark List Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority71 \lsdlocked0 Colorful Shading Accent 6;
+\lsdsemihidden0 \lsdunhideused0 \lsdpriority72 \lsdlocked0 Colorful List Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdpriority73 \lsdlocked0 Colorful Grid Accent 6;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority19 \lsdlocked0 Subtle Emphasis;
+\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority21 \lsdlocked0 Intense Emphasis;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority31 \lsdlocked0 Subtle Reference;
+\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority32 \lsdlocked0 Intense Reference;\lsdsemihidden0 \lsdunhideused0 \lsdqformat1 \lsdpriority33 \lsdlocked0 Book Title;\lsdpriority37 \lsdlocked0 Bibliography;
+\lsdqformat1 \lsdpriority39 \lsdlocked0 TOC Heading;}}{\*\datastore 0105000002000000180000004d73786d6c322e534158584d4c5265616465722e352e3000000000000000000000060000
+d0cf11e0a1b11ae1000000000000000000000000000000003e000300feff090006000000000000000000000001000000010000000000000000100000feffffff00000000feffffff0000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+fffffffffffffffffdfffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+ffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffffffffffffec69d9888b8b3d4c859eaf6cd158be0f000000000000000000000000d070
+a7c59f57c701feffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000
+00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000
+000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff000000000000000000000000000000000000000000000000
+0000000000000000000000000000000000000000000000000105000000000000}}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/RebuildMGFX.bat b/MonoGame.Framework/Graphics/Effect/Resources/RebuildMGFX.bat
new file mode 100644
index 00000000000..533e89be26d
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/Resources/RebuildMGFX.bat
@@ -0,0 +1,14 @@
+@echo off
+setlocal
+
+SET TWOMGFX="..\..\..\..\Tools\2MGFX\bin\Windows\AnyCPU\Release\2mgfx.exe"
+
+@for /f %%f IN ('dir /b *.fx') do (
+
+  call %TWOMGFX% %%~nf.fx %%~nf.ogl.mgfxo
+
+  call %TWOMGFX% %%~nf.fx %%~nf.dx11.mgfxo /Profile:DirectX_11
+
+)
+
+endlocal
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/SkinnedEffect.dx11.mgfxo b/MonoGame.Framework/Graphics/Effect/Resources/SkinnedEffect.dx11.mgfxo
new file mode 100644
index 00000000000..bc08a87ded7
Binary files /dev/null and b/MonoGame.Framework/Graphics/Effect/Resources/SkinnedEffect.dx11.mgfxo differ
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/SkinnedEffect.fx b/MonoGame.Framework/Graphics/Effect/Resources/SkinnedEffect.fx
new file mode 100644
index 00000000000..951161c7d95
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/Resources/SkinnedEffect.fx
@@ -0,0 +1,283 @@
+//-----------------------------------------------------------------------------
+// SkinnedEffect.fx
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+#include "Macros.fxh"
+
+#define SKINNED_EFFECT_MAX_BONES   72
+
+
+DECLARE_TEXTURE(Texture, 0);
+
+
+BEGIN_CONSTANTS
+
+    float4 DiffuseColor                         _vs(c0)  _ps(c1)  _cb(c0);
+    float3 EmissiveColor                        _vs(c1)  _ps(c2)  _cb(c1);
+    float3 SpecularColor                        _vs(c2)  _ps(c3)  _cb(c2);
+    float  SpecularPower                        _vs(c3)  _ps(c4)  _cb(c2.w);
+
+    float3 DirLight0Direction                   _vs(c4)  _ps(c5)  _cb(c3);
+    float3 DirLight0DiffuseColor                _vs(c5)  _ps(c6)  _cb(c4);
+    float3 DirLight0SpecularColor               _vs(c6)  _ps(c7)  _cb(c5);
+
+    float3 DirLight1Direction                   _vs(c7)  _ps(c8)  _cb(c6);
+    float3 DirLight1DiffuseColor                _vs(c8)  _ps(c9)  _cb(c7);
+    float3 DirLight1SpecularColor               _vs(c9)  _ps(c10) _cb(c8);
+
+    float3 DirLight2Direction                   _vs(c10) _ps(c11) _cb(c9);
+    float3 DirLight2DiffuseColor                _vs(c11) _ps(c12) _cb(c10);
+    float3 DirLight2SpecularColor               _vs(c12) _ps(c13) _cb(c11);
+
+    float3 EyePosition                          _vs(c13) _ps(c14) _cb(c12);
+
+    float3 FogColor                                      _ps(c0)  _cb(c13);
+    float4 FogVector                            _vs(c14)          _cb(c14);
+
+    float4x4 World                              _vs(c19)          _cb(c15);
+    float3x3 WorldInverseTranspose              _vs(c23)          _cb(c19);
+    
+    float4x3 Bones[SKINNED_EFFECT_MAX_BONES]    _vs(c26)          _cb(c22);
+
+MATRIX_CONSTANTS
+
+    float4x4 WorldViewProj                      _vs(c15)          _cb(c0);
+
+END_CONSTANTS
+
+
+#include "Structures.fxh"
+#include "Common.fxh"
+#include "Lighting.fxh"
+
+
+void Skin(inout VSInputNmTxWeights vin, uniform int boneCount)
+{
+    float4x3 skinning = 0;
+
+    [unroll]
+    for (int i = 0; i < boneCount; i++)
+    {
+        skinning += Bones[vin.Indices[i]] * vin.Weights[i];
+    }
+
+    vin.Position.xyz = mul(vin.Position, skinning);
+    vin.Normal = mul(vin.Normal, (float3x3)skinning);
+}
+
+
+// Vertex shader: vertex lighting, one bone.
+VSOutputTx VSSkinnedVertexLightingOneBone(VSInputNmTxWeights vin)
+{
+    VSOutputTx vout;
+    
+    Skin(vin, 1);
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting, two bones.
+VSOutputTx VSSkinnedVertexLightingTwoBones(VSInputNmTxWeights vin)
+{
+    VSOutputTx vout;
+    
+    Skin(vin, 2);
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting, four bones.
+VSOutputTx VSSkinnedVertexLightingFourBones(VSInputNmTxWeights vin)
+{
+    VSOutputTx vout;
+    
+    Skin(vin, 4);
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: one light, one bone.
+VSOutputTx VSSkinnedOneLightOneBone(VSInputNmTxWeights vin)
+{
+    VSOutputTx vout;
+    
+    Skin(vin, 1);
+
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: one light, two bones.
+VSOutputTx VSSkinnedOneLightTwoBones(VSInputNmTxWeights vin)
+{
+    VSOutputTx vout;
+    
+    Skin(vin, 2);
+
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: one light, four bones.
+VSOutputTx VSSkinnedOneLightFourBones(VSInputNmTxWeights vin)
+{
+    VSOutputTx vout;
+    
+    Skin(vin, 4);
+
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting, one bone.
+VSOutputPixelLightingTx VSSkinnedPixelLightingOneBone(VSInputNmTxWeights vin)
+{
+    VSOutputPixelLightingTx vout;
+    
+    Skin(vin, 1);
+
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+    
+    vout.Diffuse = float4(1, 1, 1, DiffuseColor.a);
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting, two bones.
+VSOutputPixelLightingTx VSSkinnedPixelLightingTwoBones(VSInputNmTxWeights vin)
+{
+    VSOutputPixelLightingTx vout;
+    
+    Skin(vin, 2);
+
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+    
+    vout.Diffuse = float4(1, 1, 1, DiffuseColor.a);
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting, four bones.
+VSOutputPixelLightingTx VSSkinnedPixelLightingFourBones(VSInputNmTxWeights vin)
+{
+    VSOutputPixelLightingTx vout;
+    
+    Skin(vin, 4);
+
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+    
+    vout.Diffuse = float4(1, 1, 1, DiffuseColor.a);
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Pixel shader: vertex lighting.
+float4 PSSkinnedVertexLighting(VSOutputTx pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    
+    AddSpecular(color, pin.Specular.rgb);
+    ApplyFog(color, pin.Specular.w);
+    
+    return color;
+}
+
+
+// Pixel shader: vertex lighting, no fog.
+float4 PSSkinnedVertexLightingNoFog(VSOutputTx pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    
+    AddSpecular(color, pin.Specular.rgb);
+    
+    return color;
+}
+
+
+// Pixel shader: pixel lighting.
+float4 PSSkinnedPixelLighting(VSOutputPixelLightingTx pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    
+    float3 eyeVector = normalize(EyePosition - pin.PositionWS.xyz);
+    float3 worldNormal = normalize(pin.NormalWS);
+    
+    ColorPair lightResult = ComputeLights(eyeVector, worldNormal, 3);
+    
+    color.rgb *= lightResult.Diffuse;
+
+    AddSpecular(color, lightResult.Specular);
+    ApplyFog(color, pin.PositionWS.w);
+    
+    return color;
+}
+
+
+// NOTE: The order of the techniques here are
+// defined to match the indexing in SkinnedEffect.cs.
+
+TECHNIQUE( SkinnedEffect_VertexLighting_OneBone,		VSSkinnedVertexLightingOneBone,		PSSkinnedVertexLighting );
+TECHNIQUE( SkinnedEffect_VertexLighting_OneBone_NoFog,	VSSkinnedVertexLightingOneBone,		PSSkinnedVertexLightingNoFog );
+TECHNIQUE( SkinnedEffect_VertexLighting_TwoBone,		VSSkinnedVertexLightingTwoBones,	PSSkinnedVertexLighting );
+TECHNIQUE( SkinnedEffect_VertexLighting_TwoBone_NoFog,	VSSkinnedVertexLightingTwoBones,	PSSkinnedVertexLightingNoFog );
+TECHNIQUE( SkinnedEffect_VertexLighting_FourBone,		VSSkinnedVertexLightingFourBones,	PSSkinnedVertexLighting );
+TECHNIQUE( SkinnedEffect_VertexLighting_FourBone_NoFog,	VSSkinnedVertexLightingFourBones,	PSSkinnedVertexLightingNoFog );
+
+TECHNIQUE( SkinnedEffect_OneLight_OneBone,			VSSkinnedOneLightOneBone,	PSSkinnedVertexLighting );
+TECHNIQUE( SkinnedEffect_OneLight_OneBone_NoFog,	VSSkinnedOneLightOneBone,	PSSkinnedVertexLightingNoFog );
+TECHNIQUE( SkinnedEffect_OneLight_TwoBone,			VSSkinnedOneLightTwoBones,	PSSkinnedVertexLighting );
+TECHNIQUE( SkinnedEffect_OneLight_TwoBone_NoFog,	VSSkinnedOneLightTwoBones,	PSSkinnedVertexLightingNoFog );
+TECHNIQUE( SkinnedEffect_OneLight_FourBone,			VSSkinnedOneLightFourBones,	PSSkinnedVertexLighting );
+TECHNIQUE( SkinnedEffect_OneLight_FourBone_NoFog,	VSSkinnedOneLightFourBones,	PSSkinnedVertexLightingNoFog );
+
+TECHNIQUE( SkinnedEffect_PixelLighting_OneBone,			VSSkinnedPixelLightingOneBone,		PSSkinnedPixelLighting );
+TECHNIQUE( SkinnedEffect_PixelLighting_OneBone_NoFog,	VSSkinnedPixelLightingOneBone,		PSSkinnedPixelLighting );
+TECHNIQUE( SkinnedEffect_PixelLighting_TwoBone,			VSSkinnedPixelLightingTwoBones,		PSSkinnedPixelLighting );
+TECHNIQUE( SkinnedEffect_PixelLighting_TwoBone_NoFog,	VSSkinnedPixelLightingTwoBones,		PSSkinnedPixelLighting );
+TECHNIQUE( SkinnedEffect_PixelLighting_FourBone,		VSSkinnedPixelLightingFourBones,	PSSkinnedPixelLighting );
+TECHNIQUE( SkinnedEffect_PixelLighting_FourBone_NoFog,	VSSkinnedPixelLightingFourBones,	PSSkinnedPixelLighting );
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/SkinnedEffect.ogl.mgfxo b/MonoGame.Framework/Graphics/Effect/Resources/SkinnedEffect.ogl.mgfxo
new file mode 100644
index 00000000000..1ed0bf4dbb6
Binary files /dev/null and b/MonoGame.Framework/Graphics/Effect/Resources/SkinnedEffect.ogl.mgfxo differ
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/SpriteEffect.dx11.mgfxo b/MonoGame.Framework/Graphics/Effect/Resources/SpriteEffect.dx11.mgfxo
new file mode 100644
index 00000000000..abfe2f08ebf
Binary files /dev/null and b/MonoGame.Framework/Graphics/Effect/Resources/SpriteEffect.dx11.mgfxo differ
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/SpriteEffect.fx b/MonoGame.Framework/Graphics/Effect/Resources/SpriteEffect.fx
new file mode 100644
index 00000000000..731baf69b26
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/Resources/SpriteEffect.fx
@@ -0,0 +1,46 @@
+//-----------------------------------------------------------------------------
+// SpriteEffect.fx
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+#include "Macros.fxh"
+
+
+DECLARE_TEXTURE(Texture, 0);
+
+
+BEGIN_CONSTANTS
+MATRIX_CONSTANTS
+
+    float4x4 MatrixTransform    _vs(c0) _cb(c0);
+
+END_CONSTANTS
+
+
+struct VSOutput
+{
+	float4 position		: SV_Position;
+	float4 color		: COLOR0;
+    float2 texCoord		: TEXCOORD0;
+};
+
+VSOutput SpriteVertexShader(	float4 position	: POSITION0,
+								float4 color	: COLOR0,
+								float2 texCoord	: TEXCOORD0)
+{
+	VSOutput output;
+    output.position = mul(position, MatrixTransform);
+	output.color = color;
+	output.texCoord = texCoord;
+	return output;
+}
+
+
+float4 SpritePixelShader(VSOutput input) : SV_Target0
+{
+    return SAMPLE_TEXTURE(Texture, input.texCoord) * input.color;
+}
+
+TECHNIQUE( SpriteBatch, SpriteVertexShader, SpritePixelShader );
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/SpriteEffect.ogl.mgfxo b/MonoGame.Framework/Graphics/Effect/Resources/SpriteEffect.ogl.mgfxo
new file mode 100644
index 00000000000..49ce9d2c571
Binary files /dev/null and b/MonoGame.Framework/Graphics/Effect/Resources/SpriteEffect.ogl.mgfxo differ
diff --git a/MonoGame.Framework/Graphics/Effect/Resources/Structures.fxh b/MonoGame.Framework/Graphics/Effect/Resources/Structures.fxh
new file mode 100644
index 00000000000..5c6abfb2b8c
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/Resources/Structures.fxh
@@ -0,0 +1,161 @@
+//-----------------------------------------------------------------------------
+// Structurs.fxh
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+
+// Vertex shader input structures.
+
+struct VSInput
+{
+    float4 Position : POSITION;
+};
+
+struct VSInputVc
+{
+    float4 Position : POSITION;
+    float4 Color    : COLOR;
+};
+
+struct VSInputTx
+{
+    float4 Position : POSITION;
+    float2 TexCoord : TEXCOORD;
+};
+
+struct VSInputTxVc
+{
+    float4 Position : POSITION;
+    float2 TexCoord : TEXCOORD;
+    float4 Color    : COLOR;
+};
+
+struct VSInputNm
+{
+    float4 Position : POSITION;
+    float3 Normal   : NORMAL;
+};
+
+struct VSInputNmVc
+{
+    float4 Position : POSITION;
+    float3 Normal   : NORMAL;
+    float4 Color    : COLOR;
+};
+
+struct VSInputNmTx
+{
+    float4 Position : POSITION;
+    float3 Normal   : NORMAL;
+    float2 TexCoord : TEXCOORD;
+};
+
+struct VSInputNmTxVc
+{
+    float4 Position : POSITION;
+    float3 Normal   : NORMAL;
+    float2 TexCoord : TEXCOORD;
+    float4 Color    : COLOR;
+};
+
+struct VSInputTx2
+{
+    float4 Position  : POSITION0;
+    float2 TexCoord  : TEXCOORD0;
+    float2 TexCoord2 : TEXCOORD1;
+};
+
+struct VSInputTx2Vc
+{
+    float4 Position  : POSITION0;
+    float2 TexCoord  : TEXCOORD0;
+    float2 TexCoord2 : TEXCOORD1;
+    float4 Color     : COLOR;
+};
+
+struct VSInputNmTxWeights
+{
+    float4 Position : POSITION0;
+    float3 Normal   : NORMAL0;
+    float2 TexCoord : TEXCOORD0;
+    uint4  Indices  : BLENDINDICES0;
+    float4 Weights  : BLENDWEIGHT0;
+};
+
+
+
+// Vertex shader output structures.
+
+struct VSOutput
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+    float4 Specular   : COLOR1;
+};
+
+struct VSOutputNoFog
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+};
+
+struct VSOutputTx
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+    float4 Specular   : COLOR1;
+    float2 TexCoord   : TEXCOORD0;
+};
+
+struct VSOutputTxNoFog
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+    float2 TexCoord   : TEXCOORD0;
+};
+
+struct VSOutputPixelLighting
+{
+    float4 PositionPS : SV_Position;
+    float4 PositionWS : TEXCOORD0;
+    float3 NormalWS   : TEXCOORD1;
+    float4 Diffuse    : COLOR0;
+};
+
+struct VSOutputPixelLightingTx
+{
+    float4 PositionPS : SV_Position;
+    float2 TexCoord   : TEXCOORD0;
+    float4 PositionWS : TEXCOORD1;
+    float3 NormalWS   : TEXCOORD2;
+    float4 Diffuse    : COLOR0;
+};
+
+struct VSOutputTx2
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+    float4 Specular   : COLOR1;
+    float2 TexCoord   : TEXCOORD0;
+    float2 TexCoord2  : TEXCOORD1;
+};
+
+struct VSOutputTx2NoFog
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+    float2 TexCoord   : TEXCOORD0;
+    float2 TexCoord2  : TEXCOORD1;
+};
+
+struct VSOutputTxEnvMap
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+    float4 Specular   : COLOR1;
+    float2 TexCoord   : TEXCOORD0;
+    float3 EnvCoord   : TEXCOORD1;
+};
+
diff --git a/MonoGame.Framework/Graphics/Effect/SkinnedEffect.cs b/MonoGame.Framework/Graphics/Effect/SkinnedEffect.cs
new file mode 100644
index 00000000000..a2d720fd3d3
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/SkinnedEffect.cs
@@ -0,0 +1,538 @@
+#region File Description
+//-----------------------------------------------------------------------------
+// SkinnedEffect.cs
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+#endregion
+
+#region Using Statements
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+#endregion
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Built-in effect for rendering skinned character models.
+    /// </summary>
+    public class SkinnedEffect : Effect, IEffectMatrices, IEffectLights, IEffectFog
+    {
+        public const int MaxBones = 72;
+        
+        #region Effect Parameters
+
+        EffectParameter textureParam;
+        EffectParameter diffuseColorParam;
+        EffectParameter emissiveColorParam;
+        EffectParameter specularColorParam;
+        EffectParameter specularPowerParam;
+        EffectParameter eyePositionParam;
+        EffectParameter fogColorParam;
+        EffectParameter fogVectorParam;
+        EffectParameter worldParam;
+        EffectParameter worldInverseTransposeParam;
+        EffectParameter worldViewProjParam;
+        EffectParameter bonesParam;
+
+        #endregion
+
+        #region Fields
+
+        bool preferPerPixelLighting;
+        bool oneLight;
+        bool fogEnabled;
+
+        Matrix world = Matrix.Identity;
+        Matrix view = Matrix.Identity;
+        Matrix projection = Matrix.Identity;
+
+        Matrix worldView;
+
+        Vector3 diffuseColor = Vector3.One;
+        Vector3 emissiveColor = Vector3.Zero;
+        Vector3 ambientLightColor = Vector3.Zero;
+
+        float alpha = 1;
+
+        DirectionalLight light0;
+        DirectionalLight light1;
+        DirectionalLight light2;
+
+        float fogStart = 0;
+        float fogEnd = 1;
+
+        int weightsPerVertex = 4;
+
+        EffectDirtyFlags dirtyFlags = EffectDirtyFlags.All;
+
+        #endregion
+
+        #region Public Properties
+
+
+        /// <summary>
+        /// Gets or sets the world matrix.
+        /// </summary>
+        public Matrix World
+        {
+            get { return world; }
+            
+            set
+            {
+                world = value;
+                dirtyFlags |= EffectDirtyFlags.World | EffectDirtyFlags.WorldViewProj | EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the view matrix.
+        /// </summary>
+        public Matrix View
+        {
+            get { return view; }
+            
+            set
+            {
+                view = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj | EffectDirtyFlags.EyePosition | EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the projection matrix.
+        /// </summary>
+        public Matrix Projection
+        {
+            get { return projection; }
+            
+            set
+            {
+                projection = value;
+                dirtyFlags |= EffectDirtyFlags.WorldViewProj;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material diffuse color (range 0 to 1).
+        /// </summary>
+        public Vector3 DiffuseColor
+        {
+            get { return diffuseColor; }
+            
+            set
+            {
+                diffuseColor = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material emissive color (range 0 to 1).
+        /// </summary>
+        public Vector3 EmissiveColor
+        {
+            get { return emissiveColor; }
+            
+            set
+            {
+                emissiveColor = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material specular color (range 0 to 1).
+        /// </summary>
+        public Vector3 SpecularColor
+        {
+            get { return specularColorParam.GetValueVector3(); }
+            set { specularColorParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material specular power.
+        /// </summary>
+        public float SpecularPower
+        {
+            get { return specularPowerParam.GetValueSingle(); }
+            set { specularPowerParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the material alpha.
+        /// </summary>
+        public float Alpha
+        {
+            get { return alpha; }
+            
+            set
+            {
+                alpha = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the per-pixel lighting prefer flag.
+        /// </summary>
+        public bool PreferPerPixelLighting
+        {
+            get { return preferPerPixelLighting; }
+            
+            set
+            {
+                if (preferPerPixelLighting != value)
+                {
+                    preferPerPixelLighting = value;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex;
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the ambient light color (range 0 to 1).
+        /// </summary>
+        public Vector3 AmbientLightColor
+        {
+            get { return ambientLightColor; }
+            
+            set
+            {
+                ambientLightColor = value;
+                dirtyFlags |= EffectDirtyFlags.MaterialColor;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets the first directional light.
+        /// </summary>
+        public DirectionalLight DirectionalLight0 { get { return light0; } }
+
+
+        /// <summary>
+        /// Gets the second directional light.
+        /// </summary>
+        public DirectionalLight DirectionalLight1 { get { return light1; } }
+
+
+        /// <summary>
+        /// Gets the third directional light.
+        /// </summary>
+        public DirectionalLight DirectionalLight2 { get { return light2; } }
+
+
+        /// <summary>
+        /// Gets or sets the fog enable flag.
+        /// </summary>
+        public bool FogEnabled
+        {
+            get { return fogEnabled; }
+            
+            set
+            {
+                if (fogEnabled != value)
+                {
+                    fogEnabled = value;
+                    dirtyFlags |= EffectDirtyFlags.ShaderIndex | EffectDirtyFlags.FogEnable;
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog start distance.
+        /// </summary>
+        public float FogStart
+        {
+            get { return fogStart; }
+            
+            set
+            {
+                fogStart = value;
+                dirtyFlags |= EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog end distance.
+        /// </summary>
+        public float FogEnd
+        {
+            get { return fogEnd; }
+            
+            set
+            {
+                fogEnd = value;
+                dirtyFlags |= EffectDirtyFlags.Fog;
+            }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the fog color.
+        /// </summary>
+        public Vector3 FogColor
+        {
+            get { return fogColorParam.GetValueVector3(); }
+            set { fogColorParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the current texture.
+        /// </summary>
+        public Texture2D Texture
+        {
+            get { return textureParam.GetValueTexture2D(); }
+            set { textureParam.SetValue(value); }
+        }
+
+
+        /// <summary>
+        /// Gets or sets the number of skinning weights to evaluate for each vertex (1, 2, or 4).
+        /// </summary>
+        public int WeightsPerVertex
+        {
+            get { return weightsPerVertex; }
+            
+            set
+            {
+                if ((value != 1) &&
+                    (value != 2) &&
+                    (value != 4))
+                {
+                    throw new ArgumentOutOfRangeException("value");
+                }
+
+                weightsPerVertex = value;
+                dirtyFlags |= EffectDirtyFlags.ShaderIndex;
+            }
+        }
+
+
+        /// <summary>
+        /// Sets an array of skinning bone transform matrices.
+        /// </summary>
+        public void SetBoneTransforms(Matrix[] boneTransforms)
+        {
+            if ((boneTransforms == null) || (boneTransforms.Length == 0))
+                throw new ArgumentNullException("boneTransforms");
+
+            if (boneTransforms.Length > MaxBones)
+                throw new ArgumentException();
+
+            bonesParam.SetValue(boneTransforms);
+        }
+
+
+        /// <summary>
+        /// Gets a copy of the current skinning bone transform matrices.
+        /// </summary>
+        public Matrix[] GetBoneTransforms(int count)
+        {
+            if (count <= 0 || count > MaxBones)
+                throw new ArgumentOutOfRangeException("count");
+
+            Matrix[] bones = bonesParam.GetValueMatrixArray(count);
+            
+            // Convert matrices from 43 to 44 format.
+            for (int i = 0; i < bones.Length; i++)
+            {
+                bones[i].M44 = 1;
+            }
+            
+            return bones;
+        }
+
+
+        /// <summary>
+        /// This effect requires lighting, so we explicitly implement
+        /// IEffectLights.LightingEnabled, and do not allow turning it off.
+        /// </summary>
+        bool IEffectLights.LightingEnabled
+        {
+            get { return true; }
+            set { if (!value) throw new NotSupportedException("SkinnedEffect does not support setting LightingEnabled to false."); }
+        }
+
+
+        #endregion
+
+        #region Methods
+
+
+        /// <summary>
+        /// Creates a new SkinnedEffect with default parameter settings.
+        /// </summary>
+        public SkinnedEffect(GraphicsDevice device)
+            : base(device, EffectResource.SkinnedEffect.Bytecode)
+        {
+            CacheEffectParameters(null);
+
+            DirectionalLight0.Enabled = true;
+
+            SpecularColor = Vector3.One;
+            SpecularPower = 16;
+            
+            Matrix[] identityBones = new Matrix[MaxBones];
+            
+            for (int i = 0; i < MaxBones; i++)
+            {
+                identityBones[i] = Matrix.Identity;
+            }
+            
+            SetBoneTransforms(identityBones);
+        }
+
+
+        /// <summary>
+        /// Creates a new SkinnedEffect by cloning parameter settings from an existing instance.
+        /// </summary>
+        protected SkinnedEffect(SkinnedEffect cloneSource)
+            : base(cloneSource)
+        {
+            CacheEffectParameters(cloneSource);
+
+            preferPerPixelLighting = cloneSource.preferPerPixelLighting;
+            fogEnabled = cloneSource.fogEnabled;
+
+            world = cloneSource.world;
+            view = cloneSource.view;
+            projection = cloneSource.projection;
+
+            diffuseColor = cloneSource.diffuseColor;
+            emissiveColor = cloneSource.emissiveColor;
+            ambientLightColor = cloneSource.ambientLightColor;
+
+            alpha = cloneSource.alpha;
+
+            fogStart = cloneSource.fogStart;
+            fogEnd = cloneSource.fogEnd;
+            
+            weightsPerVertex = cloneSource.weightsPerVertex;
+        }
+
+
+        /// <summary>
+        /// Creates a clone of the current SkinnedEffect instance.
+        /// </summary>
+        public override Effect Clone()
+        {
+            return new SkinnedEffect(this);
+        }
+
+
+        /// <summary>
+        /// Sets up the standard key/fill/back lighting rig.
+        /// </summary>
+        public void EnableDefaultLighting()
+        {
+            AmbientLightColor = EffectHelpers.EnableDefaultLighting(light0, light1, light2);
+        }
+
+
+        /// <summary>
+        /// Looks up shortcut references to our effect parameters.
+        /// </summary>
+        void CacheEffectParameters(SkinnedEffect cloneSource)
+        {
+            textureParam                = Parameters["Texture"];
+            diffuseColorParam           = Parameters["DiffuseColor"];
+            emissiveColorParam          = Parameters["EmissiveColor"];
+            specularColorParam          = Parameters["SpecularColor"];
+            specularPowerParam          = Parameters["SpecularPower"];
+            eyePositionParam            = Parameters["EyePosition"];
+            fogColorParam               = Parameters["FogColor"];
+            fogVectorParam              = Parameters["FogVector"];
+            worldParam                  = Parameters["World"];
+            worldInverseTransposeParam  = Parameters["WorldInverseTranspose"];
+            worldViewProjParam          = Parameters["WorldViewProj"];
+            bonesParam                  = Parameters["Bones"];
+
+            light0 = new DirectionalLight(Parameters["DirLight0Direction"],
+                                          Parameters["DirLight0DiffuseColor"],
+                                          Parameters["DirLight0SpecularColor"],
+                                          (cloneSource != null) ? cloneSource.light0 : null);
+
+            light1 = new DirectionalLight(Parameters["DirLight1Direction"],
+                                          Parameters["DirLight1DiffuseColor"],
+                                          Parameters["DirLight1SpecularColor"],
+                                          (cloneSource != null) ? cloneSource.light1 : null);
+
+            light2 = new DirectionalLight(Parameters["DirLight2Direction"],
+                                          Parameters["DirLight2DiffuseColor"],
+                                          Parameters["DirLight2SpecularColor"],
+                                          (cloneSource != null) ? cloneSource.light2 : null);
+        }
+
+
+        /// <summary>
+        /// Lazily computes derived parameter values immediately before applying the effect.
+        /// </summary>
+        protected internal override void OnApply()
+        {
+            // Recompute the world+view+projection matrix or fog vector?
+            dirtyFlags = EffectHelpers.SetWorldViewProjAndFog(dirtyFlags, ref world, ref view, ref projection, ref worldView, fogEnabled, fogStart, fogEnd, worldViewProjParam, fogVectorParam);
+
+            // Recompute the world inverse transpose and eye position?
+            dirtyFlags = EffectHelpers.SetLightingMatrices(dirtyFlags, ref world, ref view, worldParam, worldInverseTransposeParam, eyePositionParam);
+            
+            // Recompute the diffuse/emissive/alpha material color parameters?
+            if ((dirtyFlags & EffectDirtyFlags.MaterialColor) != 0)
+            {
+                EffectHelpers.SetMaterialColor(true, alpha, ref diffuseColor, ref emissiveColor, ref ambientLightColor, diffuseColorParam, emissiveColorParam);
+
+                dirtyFlags &= ~EffectDirtyFlags.MaterialColor;
+            }
+
+            // Check if we can use the only-bother-with-the-first-light shader optimization.
+            bool newOneLight = !light1.Enabled && !light2.Enabled;
+            
+            if (oneLight != newOneLight)
+            {
+                oneLight = newOneLight;
+                dirtyFlags |= EffectDirtyFlags.ShaderIndex;
+            }
+
+            // Recompute the shader index?
+            if ((dirtyFlags & EffectDirtyFlags.ShaderIndex) != 0)
+            {
+                int shaderIndex = 0;
+                
+                if (!fogEnabled)
+                    shaderIndex += 1;
+                
+                if (weightsPerVertex == 2)
+                    shaderIndex += 2;
+                else if (weightsPerVertex == 4)
+                    shaderIndex += 4;
+                
+                if (preferPerPixelLighting)
+                    shaderIndex += 12;
+                else if (oneLight)
+                    shaderIndex += 6;
+
+                dirtyFlags &= ~EffectDirtyFlags.ShaderIndex;
+
+                CurrentTechnique = Techniques[shaderIndex];
+            }
+        }
+
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Effect/SpriteEffect.cs b/MonoGame.Framework/Graphics/Effect/SpriteEffect.cs
new file mode 100644
index 00000000000..0691ca83a20
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Effect/SpriteEffect.cs
@@ -0,0 +1,88 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// The default effect used by SpriteBatch.
+    /// </summary>
+    public class SpriteEffect : Effect
+    {
+        private EffectParameter _matrixParam;
+        private Viewport _lastViewport;
+        private Matrix _projection;
+
+        /// <summary>
+        /// Creates a new SpriteEffect.
+        /// </summary>
+        public SpriteEffect(GraphicsDevice device)
+            : base(device, EffectResource.SpriteEffect.Bytecode)
+        {
+            CacheEffectParameters();
+        }
+
+        /// <summary>
+        /// An optional matrix used to transform the sprite geometry. Uses <see cref="Matrix.Identity"/> if null.
+        /// </summary>
+        public Matrix? TransformMatrix { get; set; }
+
+        /// <summary>
+        /// Creates a new SpriteEffect by cloning parameter settings from an existing instance.
+        /// </summary>
+        protected SpriteEffect(SpriteEffect cloneSource)
+            : base(cloneSource)
+        {
+            CacheEffectParameters();
+        }
+
+
+        /// <summary>
+        /// Creates a clone of the current SpriteEffect instance.
+        /// </summary>
+        public override Effect Clone()
+        {
+            return new SpriteEffect(this);
+        }
+
+
+        /// <summary>
+        /// Looks up shortcut references to our effect parameters.
+        /// </summary>
+        void CacheEffectParameters()
+        {
+            _matrixParam = Parameters["MatrixTransform"];
+        }
+
+        /// <summary>
+        /// Lazily computes derived parameter values immediately before applying the effect.
+        /// </summary>
+        protected internal override void OnApply()
+        {
+            var vp = GraphicsDevice.Viewport;
+            if ((vp.Width != _lastViewport.Width) || (vp.Height != _lastViewport.Height))
+            {
+                // Normal 3D cameras look into the -z direction (z = 1 is in front of z = 0). The
+                // sprite batch layer depth is the opposite (z = 0 is in front of z = 1).
+                // --> We get the correct matrix with near plane 0 and far plane -1.
+                Matrix.CreateOrthographicOffCenter(0, vp.Width, vp.Height, 0, 0, -1, out _projection);
+
+                if (SpriteBatch.NeedsHalfPixelOffset)
+                {
+                    _projection.M41 += -0.5f * _projection.M11;
+                    _projection.M42 += -0.5f * _projection.M22;
+                }
+
+                _lastViewport = vp;
+            }
+
+            if (TransformMatrix.HasValue)
+                _matrixParam.SetValue(TransformMatrix.GetValueOrDefault() * _projection);
+            else
+                _matrixParam.SetValue(_projection);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsAdapter.DirectX.cs b/MonoGame.Framework/Graphics/GraphicsAdapter.DirectX.cs
new file mode 100644
index 00000000000..cd146bdc5e6
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsAdapter.DirectX.cs
@@ -0,0 +1,142 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using SharpDX.Direct3D;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    partial class GraphicsAdapter
+    {
+        SharpDX.DXGI.Adapter1 _adapter;
+
+        private static void PlatformInitializeAdapters(out ReadOnlyCollection<GraphicsAdapter> adapters)
+        {
+            var factory = new SharpDX.DXGI.Factory1();
+
+            var adapterCount = factory.GetAdapterCount();
+            var adapterList = new List<GraphicsAdapter>(adapterCount);
+
+            for (var i = 0; i < adapterCount; i++)
+            {
+                var device = factory.GetAdapter1(i);
+
+                var monitorCount = device.GetOutputCount();
+                for (var j = 0; j < monitorCount; j++)
+                {
+                    var monitor = device.GetOutput(j);
+
+                    var adapter = CreateAdapter(device, monitor);
+                    adapterList.Add(adapter);
+
+                    monitor.Dispose();
+                }
+            }
+
+            factory.Dispose();
+
+            adapters = new ReadOnlyCollection<GraphicsAdapter>(adapterList);
+        }
+
+        private static readonly Dictionary<SharpDX.DXGI.Format, SurfaceFormat> FormatTranslations = new Dictionary<SharpDX.DXGI.Format, SurfaceFormat>
+        {
+            { SharpDX.DXGI.Format.R8G8B8A8_UNorm, SurfaceFormat.Color },
+            { SharpDX.DXGI.Format.B8G8R8A8_UNorm, SurfaceFormat.Color },
+            { SharpDX.DXGI.Format.B5G6R5_UNorm, SurfaceFormat.Bgr565 },
+        };
+
+        private static GraphicsAdapter CreateAdapter(SharpDX.DXGI.Adapter1 device, SharpDX.DXGI.Output monitor)
+        {            
+            var adapter = new GraphicsAdapter();
+            adapter._adapter = device;
+
+            adapter.DeviceName = monitor.Description.DeviceName.TrimEnd(new char[] {'\0'});
+            adapter.Description = device.Description1.Description.TrimEnd(new char[] {'\0'});
+            adapter.DeviceId = device.Description1.DeviceId;
+            adapter.Revision = device.Description1.Revision;
+            adapter.VendorId = device.Description1.VendorId;
+            adapter.SubSystemId = device.Description1.SubsystemId;
+            adapter.MonitorHandle = monitor.Description.MonitorHandle;
+
+            var desktopWidth = monitor.Description.DesktopBounds.Right - monitor.Description.DesktopBounds.Left;
+            var desktopHeight = monitor.Description.DesktopBounds.Bottom - monitor.Description.DesktopBounds.Top;
+
+            var modes = new List<DisplayMode>();
+
+            foreach (var formatTranslation in FormatTranslations)
+            {
+                SharpDX.DXGI.ModeDescription[] displayModes;
+
+                // This can fail on headless machines, so just assume the desktop size
+                // is a valid mode and return that... so at least our unit tests work.
+                try
+                {
+                    displayModes = monitor.GetDisplayModeList(formatTranslation.Key, 0);
+                }
+                catch (SharpDX.SharpDXException)
+                {
+                    var mode = new DisplayMode(desktopWidth, desktopHeight, SurfaceFormat.Color);
+                    modes.Add(mode);
+                    adapter._currentDisplayMode = mode;
+                    break;
+                }
+
+
+                foreach (var displayMode in displayModes)
+                {
+                    var mode = new DisplayMode(displayMode.Width, displayMode.Height, formatTranslation.Value);
+
+                    // Skip duplicate modes with the same width/height/formats.
+                    if (modes.Contains(mode))
+                        continue;
+
+                    modes.Add(mode);
+
+                    if (adapter._currentDisplayMode == null)
+                    {
+                        if (mode.Width == desktopWidth && mode.Height == desktopHeight && mode.Format == SurfaceFormat.Color)
+                            adapter._currentDisplayMode = mode;
+                    }
+                }
+            }
+
+            adapter._supportedDisplayModes = new DisplayModeCollection(modes);
+
+            if (adapter._currentDisplayMode == null) //(i.e. desktop mode wasn't found in the available modes)
+                adapter._currentDisplayMode = new DisplayMode(desktopWidth, desktopHeight, SurfaceFormat.Color);
+
+            return adapter;
+        }
+
+        private bool PlatformIsProfileSupported(GraphicsProfile graphicsProfile)
+        {
+            if(UseReferenceDevice)
+                return true;
+
+            FeatureLevel highestSupportedLevel;
+            try
+            {
+                highestSupportedLevel = SharpDX.Direct3D11.Device.GetSupportedFeatureLevel(_adapter);
+            }
+            catch (SharpDX.SharpDXException ex)
+            {
+                if (ex.ResultCode == SharpDX.DXGI.ResultCode.Unsupported) // No supported feature levels!
+                    return false;
+                throw;
+            }
+
+            switch(graphicsProfile)
+            {
+                case GraphicsProfile.Reach:
+                    return (highestSupportedLevel >= FeatureLevel.Level_9_1);
+                case GraphicsProfile.HiDef:
+                    return (highestSupportedLevel >= FeatureLevel.Level_10_0);
+                default:
+                    throw new InvalidOperationException();
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsAdapter.Legacy.cs b/MonoGame.Framework/Graphics/GraphicsAdapter.Legacy.cs
new file mode 100644
index 00000000000..5df302c4852
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsAdapter.Legacy.cs
@@ -0,0 +1,408 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+#if IOS
+using UIKit;
+#elif ANDROID
+using Android.Views;
+using Android.Runtime;
+#endif
+
+// NOTE: This is the legacy graphics adapter implementation
+// which should no longer be updated.  All new development
+// should go into the new one.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public sealed class GraphicsAdapter : IDisposable
+    {
+        /// <summary>
+        /// Defines the driver type for graphics adapter. Usable only on DirectX platforms for now.
+        /// </summary>
+        public enum DriverType
+        {
+            /// <summary>
+            /// Hardware device been used for rendering. Maximum speed and performance.
+            /// </summary>
+            Hardware,
+            /// <summary>
+            /// Emulates the hardware device on CPU. Slowly, only for testing.
+            /// </summary>
+            Reference,
+            /// <summary>
+            /// Useful when <see cref="DriverType.Hardware"/> acceleration does not work.
+            /// </summary>
+            FastSoftware
+        }
+
+        private static ReadOnlyCollection<GraphicsAdapter> _adapters;
+
+        private DisplayModeCollection _supportedDisplayModes;
+
+
+#if IOS
+		private UIScreen _screen;
+        internal GraphicsAdapter(UIScreen screen)
+        {
+            _screen = screen;
+        }
+#elif DESKTOPGL
+        int _displayIndex;
+#else
+        internal GraphicsAdapter()
+        {
+        }
+#endif
+
+        public void Dispose()
+        {
+        }
+
+        string _description = string.Empty;
+        public string Description { get { return _description; } private set { _description = value; } }
+
+        public DisplayMode CurrentDisplayMode
+        {
+            get
+            {
+#if IOS
+                return new DisplayMode((int)(_screen.Bounds.Width * _screen.Scale),
+                       (int)(_screen.Bounds.Height * _screen.Scale),
+                       SurfaceFormat.Color);
+#elif ANDROID
+                View view = ((AndroidGameWindow)Game.Instance.Window).GameView;
+                return new DisplayMode(view.Width, view.Height, SurfaceFormat.Color);
+#elif DESKTOPGL
+                var displayIndex = Sdl.Display.GetWindowDisplayIndex(SdlGameWindow.Instance.Handle);
+
+                Sdl.Display.Mode mode;
+                Sdl.Display.GetCurrentDisplayMode(displayIndex, out mode);
+
+                return new DisplayMode(mode.Width, mode.Height, SurfaceFormat.Color);
+#elif WINDOWS
+                using (var graphics = System.Drawing.Graphics.FromHwnd(IntPtr.Zero))
+                {
+                    var dc = graphics.GetHdc();
+                    int width = GetDeviceCaps(dc, HORZRES);
+                    int height = GetDeviceCaps(dc, VERTRES);
+                    graphics.ReleaseHdc(dc);
+                    return new DisplayMode(width, height, SurfaceFormat.Color);
+                }
+#else
+                return new DisplayMode(800, 600, SurfaceFormat.Color);
+#endif
+            }
+        }
+
+        public static GraphicsAdapter DefaultAdapter
+        {
+            get { return Adapters[0]; }
+        }
+
+        public static ReadOnlyCollection<GraphicsAdapter> Adapters
+        {
+            get
+            {
+                if (_adapters == null)
+                {
+#if IOS
+					_adapters = new ReadOnlyCollection<GraphicsAdapter>(
+						new [] {new GraphicsAdapter(UIScreen.MainScreen)});
+#else
+                    _adapters = new ReadOnlyCollection<GraphicsAdapter>(new[] { new GraphicsAdapter() });
+#endif
+                }
+
+                return _adapters;
+            }
+        }
+
+        /// <summary>
+        /// Used to request creation of the reference graphics device, 
+        /// or the default hardware accelerated device (when set to false).
+        /// </summary>
+        /// <remarks>
+        /// This only works on DirectX platforms where a reference graphics
+        /// device is available and must be defined before the graphics device
+        /// is created. It defaults to false.
+        /// </remarks>
+        public static bool UseReferenceDevice
+        {
+            get { return UseDriverType == DriverType.Reference; }
+            set { UseDriverType = value ? DriverType.Reference : DriverType.Hardware; }
+        }
+
+        /// <summary>
+        /// Used to request creation of a specific kind of driver.
+        /// </summary>
+        /// <remarks>
+        /// These values only work on DirectX platforms and must be defined before the graphics device
+        /// is created. <see cref="DriverType.Hardware"/> by default.
+        /// </remarks>
+        public static DriverType UseDriverType { get; set; }
+
+        /// <summary>
+        /// Queries for support of the requested render target format on the adaptor.
+        /// </summary>
+        /// <param name="graphicsProfile">The graphics profile.</param>
+        /// <param name="format">The requested surface format.</param>
+        /// <param name="depthFormat">The requested depth stencil format.</param>
+        /// <param name="multiSampleCount">The requested multisample count.</param>
+        /// <param name="selectedFormat">Set to the best format supported by the adaptor for the requested surface format.</param>
+        /// <param name="selectedDepthFormat">Set to the best format supported by the adaptor for the requested depth stencil format.</param>
+        /// <param name="selectedMultiSampleCount">Set to the best count supported by the adaptor for the requested multisample count.</param>
+        /// <returns>True if the requested format is supported by the adaptor. False if one or more of the values was changed.</returns>
+		public bool QueryRenderTargetFormat(
+			GraphicsProfile graphicsProfile,
+			SurfaceFormat format,
+			DepthFormat depthFormat,
+			int multiSampleCount,
+			out SurfaceFormat selectedFormat,
+			out DepthFormat selectedDepthFormat,
+			out int selectedMultiSampleCount)
+		{
+			selectedFormat = format;
+            selectedDepthFormat = depthFormat;
+            selectedMultiSampleCount = multiSampleCount;
+
+            // fallback for unsupported renderTarget surface formats.
+            if (selectedFormat == SurfaceFormat.Alpha8 ||
+                selectedFormat == SurfaceFormat.NormalizedByte2 ||
+                selectedFormat == SurfaceFormat.NormalizedByte4 ||
+                selectedFormat == SurfaceFormat.Dxt1 ||
+                selectedFormat == SurfaceFormat.Dxt3 ||
+                selectedFormat == SurfaceFormat.Dxt5 ||
+                selectedFormat == SurfaceFormat.Dxt1a ||
+                selectedFormat == SurfaceFormat.Dxt1SRgb ||
+                selectedFormat == SurfaceFormat.Dxt3SRgb ||
+                selectedFormat == SurfaceFormat.Dxt5SRgb)
+                selectedFormat = SurfaceFormat.Color;
+
+
+            return (format == selectedFormat) && (depthFormat == selectedDepthFormat) && (multiSampleCount == selectedMultiSampleCount);
+		}
+
+        /*
+        public string Description
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public int DeviceId
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public Guid DeviceIdentifier
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public string DeviceName
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public string DriverDll
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public Version DriverVersion
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public bool IsDefaultAdapter
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public bool IsWideScreen
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public IntPtr MonitorHandle
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public int Revision
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public int SubSystemId
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+        */
+
+#if DIRECTX
+        private static readonly Dictionary<SharpDX.DXGI.Format, SurfaceFormat> FormatTranslations = new Dictionary<SharpDX.DXGI.Format, SurfaceFormat>
+            {
+                { SharpDX.DXGI.Format.R8G8B8A8_UNorm, SurfaceFormat.Color },
+                { SharpDX.DXGI.Format.B8G8R8A8_UNorm, SurfaceFormat.Color },
+                { SharpDX.DXGI.Format.B5G6R5_UNorm, SurfaceFormat.Bgr565 },
+            };
+#endif
+
+        public DisplayModeCollection SupportedDisplayModes
+        {
+            get
+            {
+                bool displayChanged = false;
+#if DESKTOPGL
+                var displayIndex = Sdl.Display.GetWindowDisplayIndex (SdlGameWindow.Instance.Handle);
+                displayChanged = displayIndex != _displayIndex;
+#endif
+                if (_supportedDisplayModes == null || displayChanged)
+                {
+                    var modes = new List<DisplayMode>(new[] { CurrentDisplayMode, });
+
+#if DESKTOPGL
+                    _displayIndex = displayIndex;
+                    modes.Clear();
+                    
+                    var modeCount = Sdl.Display.GetNumDisplayModes(displayIndex);
+
+                    for (int i = 0;i < modeCount;i++)
+                    {
+                        Sdl.Display.Mode mode;
+                        Sdl.Display.GetDisplayMode(displayIndex, i, out mode);
+
+                        // We are only using one format, Color
+                        // mode.Format gets the Color format from SDL
+                        var displayMode = new DisplayMode(mode.Width, mode.Height, SurfaceFormat.Color);
+                        if (!modes.Contains(displayMode))
+                            modes.Add(displayMode);
+                    }
+#elif DIRECTX
+                    var dxgiFactory = new SharpDX.DXGI.Factory1();
+                    var adapter = dxgiFactory.GetAdapter(0);
+                    var output = adapter.Outputs[0];
+
+                    modes.Clear();
+                    foreach (var formatTranslation in FormatTranslations)
+                    {
+                        var displayModes = output.GetDisplayModeList(formatTranslation.Key, 0);
+                        foreach (var displayMode in displayModes)
+                        {
+                            var xnaDisplayMode = new DisplayMode(displayMode.Width, displayMode.Height, formatTranslation.Value);
+                            if (!modes.Contains(xnaDisplayMode))
+                                modes.Add(xnaDisplayMode);
+                        }
+                    }
+
+                    output.Dispose();
+                    adapter.Dispose();
+                    dxgiFactory.Dispose();
+#endif
+                    modes.Sort(delegate(DisplayMode a, DisplayMode b)
+                    {
+                        if (a == b) return 0;
+                        if (a.Format <= b.Format && a.Width <= b.Width && a.Height <= b.Height) return -1;
+                        else return 1;
+                    });
+                    _supportedDisplayModes = new DisplayModeCollection(modes);
+                }
+
+                return _supportedDisplayModes;
+            }
+        }
+
+        /*
+        public int VendorId
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+        */
+
+        /// <summary>
+        /// Gets a <see cref="System.Boolean"/> indicating whether
+        /// <see cref="GraphicsAdapter.CurrentDisplayMode"/> has a
+        /// Width:Height ratio corresponding to a widescreen <see cref="DisplayMode"/>.
+        /// Common widescreen modes include 16:9, 16:10 and 2:1.
+        /// </summary>
+        public bool IsWideScreen
+        {
+            get
+            {
+                // Common non-widescreen modes: 4:3, 5:4, 1:1
+                // Common widescreen modes: 16:9, 16:10, 2:1
+                // XNA does not appear to account for rotated displays on the desktop
+                const float limit = 4.0f / 3.0f;
+                var aspect = CurrentDisplayMode.AspectRatio;
+                return aspect > limit;
+            }
+        }
+
+        public bool IsProfileSupported(GraphicsProfile graphicsProfile)
+        {
+            if(UseReferenceDevice)
+                return true;
+
+            switch(graphicsProfile)
+            {
+                case GraphicsProfile.Reach:
+                    return true;
+                case GraphicsProfile.HiDef:
+                    bool result = true;
+                    // TODO: check adapter capabilities...
+                    return result;
+                default:
+                    throw new InvalidOperationException();
+            }
+        }
+
+#if WINDOWS && !OPENGL
+        [System.Runtime.InteropServices.DllImport("gdi32.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto, SetLastError = true, ExactSpelling = true)]
+        public static extern int GetDeviceCaps(IntPtr hDC, int nIndex);
+
+        private const int HORZRES = 8;
+        private const int VERTRES = 10;
+#endif
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsAdapter.cs b/MonoGame.Framework/Graphics/GraphicsAdapter.cs
new file mode 100644
index 00000000000..628900512f5
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsAdapter.cs
@@ -0,0 +1,180 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.ObjectModel;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public sealed partial class GraphicsAdapter : IDisposable
+    {
+        /// <summary>
+        /// Defines the driver type for graphics adapter. Usable only on DirectX platforms for now.
+        /// </summary>
+        public enum DriverType
+        {
+            /// <summary>
+            /// Hardware device been used for rendering. Maximum speed and performance.
+            /// </summary>
+            Hardware,
+            /// <summary>
+            /// Emulates the hardware device on CPU. Slowly, only for testing.
+            /// </summary>
+            Reference,
+            /// <summary>
+            /// Useful when <see cref="DriverType.Hardware"/> acceleration does not work.
+            /// </summary>
+            FastSoftware
+        }
+
+        private static readonly ReadOnlyCollection<GraphicsAdapter> _adapters;
+
+        private DisplayModeCollection _supportedDisplayModes;
+
+        private DisplayMode _currentDisplayMode;
+
+        static GraphicsAdapter()
+        {
+            // NOTE: An adapter is a monitor+device combination, so we expect
+            // at lease one adapter per connected monitor.
+            PlatformInitializeAdapters(out _adapters);
+
+            // The first adapter is considered the default.
+            _adapters[0].IsDefaultAdapter = true;
+        }
+
+        public static GraphicsAdapter DefaultAdapter
+        {
+            get { return _adapters[0]; }
+        }
+        
+        public static ReadOnlyCollection<GraphicsAdapter> Adapters 
+        {
+            get  { return _adapters; }
+        }
+
+        /// <summary>
+        /// Used to request creation of the reference graphics device, 
+        /// or the default hardware accelerated device (when set to false).
+        /// </summary>
+        /// <remarks>
+        /// This only works on DirectX platforms where a reference graphics
+        /// device is available and must be defined before the graphics device
+        /// is created. It defaults to false.
+        /// </remarks>
+        public static bool UseReferenceDevice
+        {
+            get { return UseDriverType == DriverType.Reference; }
+            set { UseDriverType = value ? DriverType.Reference : DriverType.Hardware; }
+        }
+
+        /// <summary>
+        /// Used to request creation of a specific kind of driver.
+        /// </summary>
+        /// <remarks>
+        /// These values only work on DirectX platforms and must be defined before the graphics device
+        /// is created. <see cref="DriverType.Hardware"/> by default.
+        /// </remarks>
+        public static DriverType UseDriverType { get; set; }
+
+        /// <summary>
+        /// Used to request the graphics device should be created with debugging
+        /// features enabled.
+        /// </summary>
+        public static bool UseDebugLayers { get; set; }
+
+        public string Description { get; private set; }
+
+        public int DeviceId { get; private set; }
+
+        public string DeviceName { get; private set; }
+
+        public int VendorId { get; private set; }
+
+        public bool IsDefaultAdapter { get; private set; }
+
+        public IntPtr MonitorHandle { get; private set; }
+
+        public int Revision { get; private set; }
+
+        public int SubSystemId { get; private set; }
+       
+        public DisplayModeCollection SupportedDisplayModes
+        {
+            get { return _supportedDisplayModes; }
+        }
+
+        public DisplayMode CurrentDisplayMode
+        {
+            get { return _currentDisplayMode; }
+        }
+
+        /// <summary>
+        /// Returns true if the <see cref="GraphicsAdapter.CurrentDisplayMode"/> is widescreen.
+        /// </summary>
+        /// <remarks>
+        /// Common widescreen modes include 16:9, 16:10 and 2:1.
+        /// </remarks>
+        public bool IsWideScreen
+        {
+            get
+            {
+                // Seems like XNA treats aspect ratios above 16:10 as wide screen.
+                const float minWideScreenAspect = 16.0f / 10.0f;
+                return CurrentDisplayMode.AspectRatio >= minWideScreenAspect;
+            }
+        }
+
+        /// <summary>
+        /// Queries for support of the requested render target format on the adaptor.
+        /// </summary>
+        /// <param name="graphicsProfile">The graphics profile.</param>
+        /// <param name="format">The requested surface format.</param>
+        /// <param name="depthFormat">The requested depth stencil format.</param>
+        /// <param name="multiSampleCount">The requested multisample count.</param>
+        /// <param name="selectedFormat">Set to the best format supported by the adaptor for the requested surface format.</param>
+        /// <param name="selectedDepthFormat">Set to the best format supported by the adaptor for the requested depth stencil format.</param>
+        /// <param name="selectedMultiSampleCount">Set to the best count supported by the adaptor for the requested multisample count.</param>
+        /// <returns>True if the requested format is supported by the adaptor. False if one or more of the values was changed.</returns>
+		public bool QueryRenderTargetFormat(
+			GraphicsProfile graphicsProfile,
+			SurfaceFormat format,
+			DepthFormat depthFormat,
+			int multiSampleCount,
+			out SurfaceFormat selectedFormat,
+			out DepthFormat selectedDepthFormat,
+			out int selectedMultiSampleCount)
+		{
+            selectedFormat = format;
+            selectedDepthFormat = depthFormat;
+            selectedMultiSampleCount = multiSampleCount;
+			
+            // fallback for unsupported renderTarget surface formats.
+            if (selectedFormat == SurfaceFormat.Alpha8 ||
+                selectedFormat == SurfaceFormat.NormalizedByte2 ||
+                selectedFormat == SurfaceFormat.NormalizedByte4 ||
+                selectedFormat == SurfaceFormat.Dxt1 ||
+                selectedFormat == SurfaceFormat.Dxt3 ||
+                selectedFormat == SurfaceFormat.Dxt5 ||
+                selectedFormat == SurfaceFormat.Dxt1a ||
+                selectedFormat == SurfaceFormat.Dxt1SRgb ||
+                selectedFormat == SurfaceFormat.Dxt3SRgb ||
+                selectedFormat == SurfaceFormat.Dxt5SRgb)
+                selectedFormat = SurfaceFormat.Color;
+
+            return (format == selectedFormat) && (depthFormat == selectedDepthFormat) && (multiSampleCount == selectedMultiSampleCount);
+		}
+
+        public bool IsProfileSupported(GraphicsProfile graphicsProfile)
+        {
+            return PlatformIsProfileSupported(graphicsProfile);
+        }
+
+        public void Dispose()
+        {
+            // We don't keep any resources, so we have
+            // nothing to do... just here for XNA compatibility.
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsCapabilities.DirectX.cs b/MonoGame.Framework/Graphics/GraphicsCapabilities.DirectX.cs
new file mode 100644
index 00000000000..a1378b5b5cc
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsCapabilities.DirectX.cs
@@ -0,0 +1,56 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal partial class GraphicsCapabilities
+    {
+        private void PlatformInitialize(GraphicsDevice device)
+        {
+            SupportsNonPowerOfTwo = device.GraphicsProfile == GraphicsProfile.HiDef;
+            SupportsTextureFilterAnisotropic = true;
+
+            SupportsDepth24 = true;
+            SupportsPackedDepthStencil = true;
+            SupportsDepthNonLinear = false;
+            SupportsTextureMaxLevel = true;
+
+            // Texture compression
+            SupportsDxt1 = true;
+            SupportsS3tc = true;
+
+            SupportsSRgb = true;
+
+            SupportsTextureArrays = device.GraphicsProfile == GraphicsProfile.HiDef;
+            SupportsDepthClamp = device.GraphicsProfile == GraphicsProfile.HiDef;
+            SupportsVertexTextures = device.GraphicsProfile == GraphicsProfile.HiDef;
+            SupportsFloatTextures = true;
+            SupportsHalfFloatTextures = true;
+            SupportsNormalized = true;
+
+            SupportsInstancing = true;
+
+            MaxTextureAnisotropy = (device.GraphicsProfile == GraphicsProfile.Reach) ? 2 : 16;
+
+            _maxMultiSampleCount = GetMaxMultiSampleCount(device);
+        }
+
+        private int GetMaxMultiSampleCount(GraphicsDevice device)
+        {
+            var format = SharpDXHelper.ToFormat(device.PresentationParameters.BackBufferFormat);
+            // Find the maximum supported level starting with the game's requested multisampling level
+            // and halving each time until reaching 0 (meaning no multisample support).
+            var qualityLevels = 0;
+            var maxLevel = MultiSampleCountLimit;
+            while (maxLevel > 0)
+            {
+                qualityLevels = device._d3dDevice.CheckMultisampleQualityLevels(format, maxLevel);
+                if (qualityLevels > 0)
+                    break;
+                maxLevel /= 2;
+            }
+            return maxLevel;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsCapabilities.OpenGL.cs b/MonoGame.Framework/Graphics/GraphicsCapabilities.OpenGL.cs
new file mode 100644
index 00000000000..b21ef766eb1
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsCapabilities.OpenGL.cs
@@ -0,0 +1,120 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+#if OPENGL
+using MonoGame.OpenGL;
+using GetParamName = MonoGame.OpenGL.GetPName;
+#endif
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+
+    internal partial class GraphicsCapabilities
+    {
+        /// <summary>
+        /// True, if GL_ARB_framebuffer_object is supported; false otherwise.
+        /// </summary>
+        internal bool SupportsFramebufferObjectARB { get; private set; }
+
+        /// <summary>
+        /// True, if GL_EXT_framebuffer_object is supported; false otherwise.
+        /// </summary>
+        internal bool SupportsFramebufferObjectEXT { get; private set; }
+
+        /// <summary>
+        /// True, if GL_IMG_multisampled_render_to_texture is supported; false otherwise.
+        /// </summary>
+        internal bool SupportsFramebufferObjectIMG { get; private set; }
+
+
+        private void PlatformInitialize(GraphicsDevice device)
+        {
+#if GLES
+            SupportsNonPowerOfTwo = GL.Extensions.Contains("GL_OES_texture_npot") ||
+                GL.Extensions.Contains("GL_ARB_texture_non_power_of_two") ||
+                GL.Extensions.Contains("GL_IMG_texture_npot") ||
+                GL.Extensions.Contains("GL_NV_texture_npot_2D_mipmap");
+#else
+            // Unfortunately non PoT texture support is patchy even on desktop systems and we can't
+            // rely on the fact that GL2.0+ supposedly supports npot in the core.
+            // Reference: http://aras-p.info/blog/2012/10/17/non-power-of-two-textures/
+            SupportsNonPowerOfTwo = device._maxTextureSize >= 8192;
+#endif
+
+            SupportsTextureFilterAnisotropic = GL.Extensions.Contains("GL_EXT_texture_filter_anisotropic");
+
+#if GLES
+			SupportsDepth24 = GL.Extensions.Contains("GL_OES_depth24");
+			SupportsPackedDepthStencil = GL.Extensions.Contains("GL_OES_packed_depth_stencil");
+			SupportsDepthNonLinear = GL.Extensions.Contains("GL_NV_depth_nonlinear");
+            SupportsTextureMaxLevel = GL.Extensions.Contains("GL_APPLE_texture_max_level");
+#else
+            SupportsDepth24 = true;
+            SupportsPackedDepthStencil = true;
+            SupportsDepthNonLinear = false;
+            SupportsTextureMaxLevel = true;
+#endif
+            // Texture compression
+            SupportsS3tc = GL.Extensions.Contains("GL_EXT_texture_compression_s3tc") ||
+                           GL.Extensions.Contains("GL_OES_texture_compression_S3TC") ||
+                           GL.Extensions.Contains("GL_EXT_texture_compression_dxt3") ||
+                           GL.Extensions.Contains("GL_EXT_texture_compression_dxt5");
+            SupportsDxt1 = SupportsS3tc || GL.Extensions.Contains("GL_EXT_texture_compression_dxt1");
+            SupportsPvrtc = GL.Extensions.Contains("GL_IMG_texture_compression_pvrtc");
+            SupportsEtc1 = GL.Extensions.Contains("GL_OES_compressed_ETC1_RGB8_texture");
+            SupportsAtitc = GL.Extensions.Contains("GL_ATI_texture_compression_atitc") ||
+                            GL.Extensions.Contains("GL_AMD_compressed_ATC_texture");
+
+            // Framebuffer objects
+#if GLES
+            SupportsFramebufferObjectARB = GL.BoundApi == GL.RenderApi.ES && (device.glMajorVersion >= 2 || GL.Extensions.Contains("GL_ARB_framebuffer_object")); // always supported on GLES 2.0+
+            SupportsFramebufferObjectEXT = GL.Extensions.Contains("GL_EXT_framebuffer_object");;
+            SupportsFramebufferObjectIMG = GL.Extensions.Contains("GL_IMG_multisampled_render_to_texture") |
+                                                 GL.Extensions.Contains("GL_APPLE_framebuffer_multisample") |
+                                                 GL.Extensions.Contains("GL_EXT_multisampled_render_to_texture") |
+                                                 GL.Extensions.Contains("GL_NV_framebuffer_multisample");
+#else
+            // if we're on GL 3.0+, frame buffer extensions are guaranteed to be present, but extensions may be missing
+            // it is then safe to assume that GL_ARB_framebuffer_object is present so that the standard function are loaded
+            SupportsFramebufferObjectARB = device.glMajorVersion >= 3 || GL.Extensions.Contains("GL_ARB_framebuffer_object");
+            SupportsFramebufferObjectEXT = GL.Extensions.Contains("GL_EXT_framebuffer_object");
+#endif
+            // Anisotropic filtering
+            int anisotropy = 0;
+            if (SupportsTextureFilterAnisotropic)
+            {
+                GL.GetInteger((GetPName)GetParamName.MaxTextureMaxAnisotropyExt, out anisotropy);
+                GraphicsExtensions.CheckGLError();
+            }
+            MaxTextureAnisotropy = anisotropy;
+
+            // sRGB
+#if GLES
+            SupportsSRgb = GL.Extensions.Contains("GL_EXT_sRGB");
+            SupportsFloatTextures = GL.BoundApi == GL.RenderApi.ES && (device.glMajorVersion >= 3 || GL.Extensions.Contains("GL_EXT_color_buffer_float"));
+            SupportsHalfFloatTextures = GL.BoundApi == GL.RenderApi.ES && (device.glMajorVersion >= 3 || GL.Extensions.Contains("GL_EXT_color_buffer_half_float"));
+            SupportsNormalized = GL.BoundApi == GL.RenderApi.ES && (device.glMajorVersion >= 3 && GL.Extensions.Contains("GL_EXT_texture_norm16"));
+#else
+            SupportsSRgb = GL.Extensions.Contains("GL_EXT_texture_sRGB") && GL.Extensions.Contains("GL_EXT_framebuffer_sRGB");
+            SupportsFloatTextures = GL.BoundApi == GL.RenderApi.GL && (device.glMajorVersion >= 3 || GL.Extensions.Contains("GL_ARB_texture_float"));
+            SupportsHalfFloatTextures = GL.BoundApi == GL.RenderApi.GL && (device.glMajorVersion >= 3 || GL.Extensions.Contains("GL_ARB_half_float_pixel"));;
+            SupportsNormalized = GL.BoundApi == GL.RenderApi.GL && (device.glMajorVersion >= 3 || GL.Extensions.Contains("GL_EXT_texture_norm16"));;
+#endif
+
+            // TODO: Implement OpenGL support for texture arrays
+            // once we can author shaders that use texture arrays.
+            SupportsTextureArrays = false;
+
+            SupportsDepthClamp = GL.Extensions.Contains("GL_ARB_depth_clamp");
+
+            SupportsVertexTextures = false; // For now, until we implement vertex textures in OpenGL.
+
+
+            GL.GetInteger((GetPName)GetParamName.MaxSamples, out _maxMultiSampleCount);
+
+            SupportsInstancing = GL.VertexAttribDivisor != null;
+        }
+
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsCapabilities.Web.cs b/MonoGame.Framework/Graphics/GraphicsCapabilities.Web.cs
new file mode 100644
index 00000000000..c113839caf7
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsCapabilities.Web.cs
@@ -0,0 +1,17 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal partial class GraphicsCapabilities
+    {
+        private void PlatformInitialize(GraphicsDevice device)
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/GraphicsCapabilities.cs b/MonoGame.Framework/Graphics/GraphicsCapabilities.cs
new file mode 100644
index 00000000000..9996c234bed
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsCapabilities.cs
@@ -0,0 +1,120 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Provides information about the capabilities of the
+    /// current graphics device. A very useful thread for investigating GL extenion names
+    /// http://stackoverflow.com/questions/3881197/opengl-es-2-0-extensions-on-android-devices
+    /// </summary>
+    internal partial class GraphicsCapabilities
+    {
+        internal void Initialize(GraphicsDevice device)
+        {
+            PlatformInitialize(device);
+        }
+
+        /// <summary>
+        /// Whether the device fully supports non power-of-two textures, including
+        /// mip maps and wrap modes other than CLAMP_TO_EDGE
+        /// </summary>
+        internal bool SupportsNonPowerOfTwo { get; private set; }
+
+        /// <summary>
+        /// Whether the device supports anisotropic texture filtering
+        /// </summary>
+		internal bool SupportsTextureFilterAnisotropic { get; private set; }
+
+        internal bool SupportsDepth24 { get; private set; }
+
+        internal bool SupportsPackedDepthStencil { get; private set; }
+
+        internal bool SupportsDepthNonLinear { get; private set; }
+
+        /// <summary>
+        /// Gets the support for DXT1
+        /// </summary>
+        internal bool SupportsDxt1 { get; private set; }
+
+        /// <summary>
+        /// Gets the support for S3TC (DXT1, DXT3, DXT5)
+        /// </summary>
+        internal bool SupportsS3tc { get; private set; }
+
+        /// <summary>
+        /// Gets the support for PVRTC
+        /// </summary>
+        internal bool SupportsPvrtc { get; private set; }
+
+        /// <summary>
+        /// Gets the support for ETC1
+        /// </summary>
+        internal bool SupportsEtc1 { get; private set; }
+
+        /// <summary>
+        /// Gets the support for ATITC
+        /// </summary>
+        internal bool SupportsAtitc { get; private set; }
+
+        internal bool SupportsTextureMaxLevel { get; private set; }
+
+        /// <summary>
+        /// True, if sRGB is supported. On Direct3D platforms, this is always <code>true</code>.
+        /// On OpenGL platforms, it is <code>true</code> if both framebuffer sRGB
+        /// and texture sRGB are supported.
+        /// </summary>
+        internal bool SupportsSRgb { get; private set; }
+
+        internal bool SupportsTextureArrays { get; private set; }
+
+        internal bool SupportsDepthClamp { get; private set; }
+
+        internal bool SupportsVertexTextures { get; private set; }
+
+        /// <summary>
+        /// True, if the underlying platform supports floating point textures. 
+        /// For Direct3D platforms this is always <code>true</code>.
+        /// For OpenGL Desktop platforms it is always <code>true</code>.
+        /// For OpenGL Mobile platforms it requires `GL_EXT_color_buffer_float`.
+        /// If the requested format is not supported an <code>NotSupportedException</code>
+        /// will be thrown.
+        /// </summary>
+        internal bool SupportsFloatTextures { get; private set; }
+
+        /// <summary>
+        /// True, if the underlying platform supports half floating point textures. 
+        /// For Direct3D platforms this is always <code>true</code>.
+        /// For OpenGL Desktop platforms it is always <code>true</code>.
+        /// For OpenGL Mobile platforms it requires `GL_EXT_color_buffer_half_float`.
+        /// If the requested format is not supported an <code>NotSupportedException</code>
+        /// will be thrown.
+        /// </summary>
+        internal bool SupportsHalfFloatTextures { get; private set; }
+
+        internal bool SupportsNormalized { get; private set; }
+
+        /// <summary>
+        /// Gets the max texture anisotropy. This value typically lies
+        /// between 0 and 16, where 0 means anisotropic filtering is not
+        /// supported.
+        /// </summary>
+        internal int MaxTextureAnisotropy { get; private set; }
+
+        // The highest possible MSCount
+        private const int MultiSampleCountLimit = 32;
+
+        private int _maxMultiSampleCount;
+
+        internal int MaxMultiSampleCount
+        {
+            get { return _maxMultiSampleCount; }
+        }
+
+        internal bool SupportsInstancing { get; private set; }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsContext.SDL.cs b/MonoGame.Framework/Graphics/GraphicsContext.SDL.cs
new file mode 100644
index 00000000000..f6a2756b0c4
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsContext.SDL.cs
@@ -0,0 +1,94 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace MonoGame.OpenGL
+{
+    internal class GraphicsContext : IGraphicsContext, IDisposable
+    {
+        private IntPtr _context;
+        private IntPtr _winHandle;
+        private bool _disposed;
+
+        public int SwapInterval
+        {
+            get
+            {
+                return Sdl.GL.GetSwapInterval();
+            }
+            set
+            {
+                Sdl.GL.SetSwapInterval(value);
+            }
+        }
+
+        public bool IsDisposed
+        {
+            get { return _disposed; }
+        }
+
+		public bool IsCurrent
+		{
+			get { return true; }
+		}
+
+        public GraphicsContext(IWindowInfo info)
+        {
+            if (_disposed)
+                return;
+            
+            SetWindowHandle(info);
+            _context = Sdl.GL.CreateContext(_winHandle);
+
+            // GL entry points must be loaded after the GL context creation, otherwise some Windows drivers will return only GL 1.3 compatible functions
+            try
+            {
+                OpenGL.GL.LoadEntryPoints();
+            }
+            catch (EntryPointNotFoundException)
+            {
+                throw new PlatformNotSupportedException(
+                    "MonoGame requires OpenGL 3.0 compatible drivers, or either ARB_framebuffer_object or EXT_framebuffer_object extensions. " +
+                    "Try updating your graphics drivers.");
+            }
+        }
+
+        public void MakeCurrent(IWindowInfo info)
+        {
+            if (_disposed)
+                return;
+            
+            SetWindowHandle(info);
+            Sdl.GL.MakeCurrent(_winHandle, _context);
+        }
+
+        public void SwapBuffers()
+        {
+            if (_disposed)
+                return;
+            
+            Sdl.GL.SwapWindow(_winHandle);
+        }
+
+        public void Dispose()
+        {
+            if (_disposed)
+                return;
+
+            GraphicsDevice.DisposeContext(_context);
+            _context = IntPtr.Zero;
+            _disposed = true;
+        }
+
+        private void SetWindowHandle(IWindowInfo info)
+        {
+            if (info == null)
+                _winHandle = IntPtr.Zero;
+            else
+                _winHandle = info.Handle;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsDebug.Default.cs b/MonoGame.Framework/Graphics/GraphicsDebug.Default.cs
new file mode 100644
index 00000000000..912fdfaeda8
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsDebug.Default.cs
@@ -0,0 +1,15 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class GraphicsDebug
+    {
+        private bool PlatformTryDequeueMessage(out GraphicsDebugMessage message)
+        {
+            message = null;
+            return false;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsDebug.DirectX.cs b/MonoGame.Framework/Graphics/GraphicsDebug.DirectX.cs
new file mode 100644
index 00000000000..ccf0f44dbd8
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsDebug.DirectX.cs
@@ -0,0 +1,82 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using SharpDX.Direct3D11;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class GraphicsDebug
+    {
+        private readonly GraphicsDevice _device;
+        private readonly InfoQueue _infoQueue;
+        private readonly Queue<GraphicsDebugMessage> _cachedMessages;
+        private bool _hasPushedFilters = false;
+
+        public GraphicsDebug(GraphicsDevice device)
+        {
+            _device = device;
+            _infoQueue = _device._d3dDevice.QueryInterfaceOrNull<InfoQueue>();
+            _cachedMessages = new Queue<GraphicsDebugMessage>();
+
+            if (_infoQueue != null)
+            {
+                _infoQueue.PushEmptyRetrievalFilter();
+                _infoQueue.PushEmptyStorageFilter();
+                _hasPushedFilters = true;
+            }
+        }
+
+        private bool PlatformTryDequeueMessage(out GraphicsDebugMessage message)
+        {
+            if (_infoQueue == null)
+            {
+                message = null;
+                return false;
+            }
+
+            if (!_hasPushedFilters)
+            {
+                _infoQueue.PushEmptyRetrievalFilter();
+                _infoQueue.PushEmptyStorageFilter();
+                _hasPushedFilters = true;
+            }
+
+            if (_cachedMessages.Count > 0)
+            {
+                message = _cachedMessages.Dequeue();
+                return true;
+            }
+
+            if (_infoQueue.NumStoredMessagesAllowedByRetrievalFilter > 0)
+            {
+                // Grab all current messages and put them in the cached messages queue.
+                for (var i = 0; i < _infoQueue.NumStoredMessagesAllowedByRetrievalFilter; i++)
+                {
+                    var dxMessage = _infoQueue.GetMessage(i);
+                    _cachedMessages.Enqueue(new GraphicsDebugMessage
+                    {
+                        Message = dxMessage.Description,
+                        Id = (int)dxMessage.Id,
+                        IdName = dxMessage.Id.ToString(),
+                        Severity = dxMessage.Severity.ToString(),
+                        Category = dxMessage.Category.ToString()
+                    });
+                }
+
+                _infoQueue.ClearStoredMessages();
+            }
+            
+            if (_cachedMessages.Count > 0)
+            {
+                message = _cachedMessages.Dequeue();
+                return true;
+            }
+            
+            // No messages to grab from DirectX.
+            message = null;
+            return false;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsDebug.cs b/MonoGame.Framework/Graphics/GraphicsDebug.cs
new file mode 100644
index 00000000000..615dadb9b4f
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsDebug.cs
@@ -0,0 +1,24 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class GraphicsDebug
+    {
+        /// <summary>
+        /// Attempt to dequeue a debugging message from the graphics subsystem.
+        /// </summary>
+        /// <remarks>
+        /// When running on a graphics device with debugging enabled, this allows you to retrieve
+        /// subsystem-specific (e.g. DirectX, OpenGL, etc.) debugging messages including information
+        /// about improper usage of shaders and APIs.
+        /// </remarks>
+        /// <param name="message">The graphics debugging message if retrieved, null otherwise.</param>
+        /// <returns>True if a graphics debugging message was retrieved, false otherwise.</returns>
+        public bool TryDequeueMessage(out GraphicsDebugMessage message)
+        {
+            return PlatformTryDequeueMessage(out message);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsDebugMessage.cs b/MonoGame.Framework/Graphics/GraphicsDebugMessage.cs
new file mode 100644
index 00000000000..6b530167dd1
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsDebugMessage.cs
@@ -0,0 +1,19 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public class GraphicsDebugMessage
+    {
+        public string Message { get; set; }
+
+        public string Severity { get; set; }
+
+        public int Id { get; set; }
+
+        public string IdName { get; set; }
+
+        public string Category { get; set; }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsDevice.DirectX.cs b/MonoGame.Framework/Graphics/GraphicsDevice.DirectX.cs
new file mode 100644
index 00000000000..e1987c6483a
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsDevice.DirectX.cs
@@ -0,0 +1,1619 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using MonoGame.Utilities;
+using SharpDX;
+using SharpDX.Direct3D;
+using SharpDX.Direct3D11;
+using SharpDX.Mathematics.Interop;
+using SharpDX.DXGI;
+
+#if WINDOWS_UAP
+using Windows.UI.Xaml.Controls;
+using Windows.Graphics.Display;
+using Windows.UI.Core;
+using System.Runtime.InteropServices;
+#endif
+
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class GraphicsDevice
+    {
+        // Core Direct3D Objects
+        internal SharpDX.Direct3D11.Device _d3dDevice;
+        internal SharpDX.Direct3D11.DeviceContext _d3dContext;
+        internal SharpDX.Direct3D11.RenderTargetView _renderTargetView;
+        internal SharpDX.Direct3D11.DepthStencilView _depthStencilView;
+        private int _vertexBufferSlotsUsed;
+
+#if WINDOWS_UAP
+
+        // Declare Direct2D Objects
+        SharpDX.Direct2D1.Factory1 _d2dFactory;
+        SharpDX.Direct2D1.Device _d2dDevice;
+        SharpDX.Direct2D1.DeviceContext _d2dContext;
+
+        // Declare DirectWrite & Windows Imaging Component Objects
+        SharpDX.DirectWrite.Factory _dwriteFactory;
+        SharpDX.WIC.ImagingFactory2 _wicFactory;
+
+        // The swap chain resources.
+        SharpDX.Direct2D1.Bitmap1 _bitmapTarget;
+        SharpDX.DXGI.SwapChain1 _swapChain;
+
+#if WINDOWS_UAP
+		SwapChainPanel _swapChainPanel;
+#else
+		SwapChainBackgroundPanel _swapChainBackgroundPanel;
+#endif
+
+		float _dpi; 
+#endif
+#if WINDOWS
+
+        SwapChain _swapChain;
+
+#endif
+
+        // The active render targets.
+        readonly SharpDX.Direct3D11.RenderTargetView[] _currentRenderTargets = new SharpDX.Direct3D11.RenderTargetView[4];
+
+        // The active depth view.
+        SharpDX.Direct3D11.DepthStencilView _currentDepthStencilView;
+
+        private readonly Dictionary<VertexDeclaration, DynamicVertexBuffer> _userVertexBuffers = new Dictionary<VertexDeclaration, DynamicVertexBuffer>();
+        private DynamicIndexBuffer _userIndexBuffer16;
+        private DynamicIndexBuffer _userIndexBuffer32;
+
+#if WINDOWS_UAP
+
+        internal float Dpi
+        {
+            get { return _dpi; }
+            set
+            {
+                if (_dpi == value)
+                    return;
+
+                _dpi = value;
+                _d2dContext.DotsPerInch = new Size2F(_dpi, _dpi);
+
+                //if (OnDpiChanged != null)
+                    //OnDpiChanged(this);
+            }
+        }
+
+#endif
+
+        /// <summary>
+        /// Returns a handle to internal device object. Valid only on DirectX platforms.
+        /// For usage, convert this to SharpDX.Direct3D11.Device.
+        /// </summary>
+        public object Handle
+        {
+            get
+            {
+                return _d3dDevice;
+            }
+        }
+
+        private void PlatformSetup()
+        {
+            MaxTextureSlots = 16;
+            MaxVertexTextureSlots = 16;
+
+#if WINDOWS_UAP
+			CreateDeviceIndependentResources();
+			CreateDeviceResources();
+			Dpi = DisplayInformation.GetForCurrentView().LogicalDpi;
+#endif
+#if WINDOWS
+            CreateDeviceResources();
+#endif
+
+            _maxVertexBufferSlots = _d3dDevice.FeatureLevel >= FeatureLevel.Level_11_0 ? SharpDX.Direct3D11.InputAssemblerStage.VertexInputResourceSlotCount : 16;
+        }
+
+        private void PlatformInitialize()
+        {
+#if WINDOWS
+            CorrectBackBufferSize();
+#endif
+            CreateSizeDependentResources();
+        }
+
+#if WINDOWS_UAP
+
+        /// <summary>
+        /// Creates resources not tied the active graphics device.
+        /// </summary>
+        protected void CreateDeviceIndependentResources()
+        {
+#if DEBUG
+            var debugLevel = SharpDX.Direct2D1.DebugLevel.Information;
+#else
+            var debugLevel = SharpDX.Direct2D1.DebugLevel.None; 
+#endif
+            // Dispose previous references.
+            if (_d2dFactory != null)
+                _d2dFactory.Dispose();
+            if (_dwriteFactory != null)
+                _dwriteFactory.Dispose();
+            if (_wicFactory != null)
+                _wicFactory.Dispose();
+
+            // Allocate new references
+            _d2dFactory = new SharpDX.Direct2D1.Factory1(SharpDX.Direct2D1.FactoryType.SingleThreaded, debugLevel);
+            _dwriteFactory = new SharpDX.DirectWrite.Factory(SharpDX.DirectWrite.FactoryType.Shared);
+            _wicFactory = new SharpDX.WIC.ImagingFactory2();
+        }
+
+        /// <summary>
+        /// Create graphics device specific resources.
+        /// </summary>
+        protected virtual void CreateDeviceResources()
+        {
+            // Dispose previous references.
+            if (_d3dDevice != null)
+                _d3dDevice.Dispose();
+            if (_d3dContext != null)
+                _d3dContext.Dispose();
+            if (_d2dDevice != null)
+                _d2dDevice.Dispose();
+            if (_d2dContext != null)
+                _d2dContext.Dispose();
+
+            // Windows requires BGRA support out of DX.
+            var creationFlags = SharpDX.Direct3D11.DeviceCreationFlags.BgraSupport;
+#if DEBUG
+            var enableDebugLayers = true;
+#else 
+            var enableDebugLayers = false;
+#endif
+
+            if (GraphicsAdapter.UseDebugLayers)
+            {
+                enableDebugLayers = true;
+            }
+
+            if (enableDebugLayers)
+            {
+                creationFlags |= SharpDX.Direct3D11.DeviceCreationFlags.Debug;
+            }
+
+            // Pass the preferred feature levels based on the
+            // target profile that may have been set by the user.
+            FeatureLevel[] featureLevels;
+            if (GraphicsProfile == GraphicsProfile.HiDef)
+            {
+                featureLevels = new[]
+                    {
+                        FeatureLevel.Level_11_1,
+                        FeatureLevel.Level_11_0,
+                        FeatureLevel.Level_10_1,
+                        FeatureLevel.Level_10_0,
+                        // Feature levels below 10 are not supported for the HiDef profile
+                    };
+            }
+            else // Reach profile
+            {
+                featureLevels = new[]
+                    {
+                        // For the Reach profile, first try use the highest supported 9_X feature level
+                        FeatureLevel.Level_9_3,
+                        FeatureLevel.Level_9_2,
+                        FeatureLevel.Level_9_1,
+                        // If level 9 is not supported, then just use the highest supported level
+                        FeatureLevel.Level_11_1,
+                        FeatureLevel.Level_11_0,
+                        FeatureLevel.Level_10_1,
+                        FeatureLevel.Level_10_0,
+                    };
+            }
+
+            var driverType = GraphicsAdapter.UseReferenceDevice ? DriverType.Reference : DriverType.Hardware;
+        
+            try 
+            {
+                // Create the Direct3D device.
+                using (var defaultDevice = new SharpDX.Direct3D11.Device(driverType, creationFlags, featureLevels))
+                    _d3dDevice = defaultDevice.QueryInterface<SharpDX.Direct3D11.Device1>();
+
+                // Necessary to enable video playback
+                var multithread = _d3dDevice.QueryInterface<SharpDX.Direct3D.DeviceMultithread>();
+                multithread.SetMultithreadProtected(true);
+            }
+            catch(SharpDXException)
+            {
+                // Try again without the debug flag.  This allows debug builds to run
+                // on machines that don't have the debug runtime installed.
+                creationFlags &= ~SharpDX.Direct3D11.DeviceCreationFlags.Debug;
+                using (var defaultDevice = new SharpDX.Direct3D11.Device(driverType, creationFlags, featureLevels))
+                    _d3dDevice = defaultDevice.QueryInterface<SharpDX.Direct3D11.Device1>();
+            }
+
+            // Get Direct3D 11.1 context
+            _d3dContext = _d3dDevice.ImmediateContext.QueryInterface<SharpDX.Direct3D11.DeviceContext1>();
+
+            // Create the Direct2D device.
+            using (var dxgiDevice = _d3dDevice.QueryInterface<SharpDX.DXGI.Device>())
+                _d2dDevice = new SharpDX.Direct2D1.Device(_d2dFactory, dxgiDevice);
+
+            // Create Direct2D context
+            _d2dContext = new SharpDX.Direct2D1.DeviceContext(_d2dDevice, SharpDX.Direct2D1.DeviceContextOptions.None);
+        }
+
+        internal void CreateSizeDependentResources()
+        {
+            // Clamp MultiSampleCount
+            PresentationParameters.MultiSampleCount =
+                GetClampedMultisampleCount(PresentationParameters.MultiSampleCount);
+
+            _d3dContext.OutputMerger.SetTargets((SharpDX.Direct3D11.DepthStencilView)null, 
+                                                (SharpDX.Direct3D11.RenderTargetView)null);  
+
+            _d2dContext.Target = null;
+            if (_renderTargetView != null)
+            {
+                _renderTargetView.Dispose();
+                _renderTargetView = null;
+            }
+            if (_depthStencilView != null)
+            {
+                _depthStencilView.Dispose();
+                _depthStencilView = null;
+            }
+            if (_bitmapTarget != null)
+            {
+                _bitmapTarget.Dispose();
+                _bitmapTarget = null;
+            }
+
+			// Clear the current render targets.
+            _currentDepthStencilView = null;
+            Array.Clear(_currentRenderTargets, 0, _currentRenderTargets.Length);
+            Array.Clear(_currentRenderTargetBindings, 0, _currentRenderTargetBindings.Length);
+            _currentRenderTargetCount = 0;
+
+			// Make sure all pending rendering commands are flushed.
+            _d3dContext.Flush();
+
+            // We need presentation parameters to continue here.
+            if (    PresentationParameters == null ||
+					(PresentationParameters.DeviceWindowHandle == IntPtr.Zero && PresentationParameters.SwapChainPanel == null))
+			{
+                if (_swapChain != null)
+                {
+                    _swapChain.Dispose();
+                    _swapChain = null;
+                }
+
+                return;
+            }
+
+			// Did we change swap panels?
+			if (PresentationParameters.SwapChainPanel != _swapChainPanel)
+			{
+				_swapChainPanel = null;
+
+				if (_swapChain != null)
+                {
+                    _swapChain.Dispose();
+                    _swapChain = null;
+                }                
+            }
+
+            var format = SharpDXHelper.ToFormat(PresentationParameters.BackBufferFormat);
+            var multisampleDesc = GetSupportedSampleDescription(
+                format, 
+                PresentationParameters.MultiSampleCount);
+
+            // If the swap chain already exists... update it.
+            if (_swapChain != null)
+            {
+                _swapChain.ResizeBuffers(   2,
+                                            PresentationParameters.BackBufferWidth,
+                                            PresentationParameters.BackBufferHeight,
+                                            format, 
+                                            SwapChainFlags.None);
+           }
+
+            // Otherwise, create a new swap chain.
+            else
+            {
+                // SwapChain description
+                var desc = new SharpDX.DXGI.SwapChainDescription1()
+                {
+                    // Automatic sizing
+                    Width = PresentationParameters.BackBufferWidth,
+                    Height = PresentationParameters.BackBufferHeight,
+                    Format = format,
+                    Stereo = false,
+                    SampleDescription = multisampleDesc,
+                    Usage = SharpDX.DXGI.Usage.RenderTargetOutput,
+                    BufferCount = 2,
+                    SwapEffect = SharpDXHelper.ToSwapEffect(PresentationParameters.PresentationInterval),
+
+                    // By default we scale the backbuffer to the window 
+                    // rectangle to function more like a WP7 game.
+                    Scaling = SharpDX.DXGI.Scaling.Stretch,
+                };
+
+                // Once the desired swap chain description is configured, it must be created on the same adapter as our D3D Device
+
+                // First, retrieve the underlying DXGI Device from the D3D Device.
+                // Creates the swap chain 
+                using (var dxgiDevice2 = _d3dDevice.QueryInterface<SharpDX.DXGI.Device2>())
+                using (var dxgiAdapter = dxgiDevice2.Adapter)
+                using (var dxgiFactory2 = dxgiAdapter.GetParent<SharpDX.DXGI.Factory2>())
+                {
+                    if (PresentationParameters.DeviceWindowHandle != IntPtr.Zero)
+                    {
+                        // Creates a SwapChain from a CoreWindow pointer.
+                        var coreWindow = Marshal.GetObjectForIUnknown(PresentationParameters.DeviceWindowHandle) as CoreWindow;
+                        using (var comWindow = new ComObject(coreWindow))
+                           _swapChain = new SwapChain1(dxgiFactory2, dxgiDevice2, comWindow, ref desc);
+                    }
+                    else
+                    {
+						_swapChainPanel = PresentationParameters.SwapChainPanel;
+						using (var nativePanel = ComObject.As<SharpDX.DXGI.ISwapChainPanelNative>(PresentationParameters.SwapChainPanel))
+						{
+							_swapChain = new SwapChain1(dxgiFactory2, dxgiDevice2, ref desc, null);
+							nativePanel.SwapChain = _swapChain;
+						}
+                    }
+
+                    // Ensure that DXGI does not queue more than one frame at a time. This both reduces 
+                    // latency and ensures that the application will only render after each VSync, minimizing 
+                    // power consumption.
+                    dxgiDevice2.MaximumFrameLatency = 1;
+                }
+            }
+
+            _swapChain.Rotation = SharpDX.DXGI.DisplayModeRotation.Identity;
+
+            // Counter act the composition scale of the render target as 
+            // we already handle this in the platform window code. 
+            if (PresentationParameters.SwapChainPanel != null)
+            {
+                var asyncResult = PresentationParameters.SwapChainPanel.Dispatcher.RunIdleAsync( (e) =>
+                {   
+                var inverseScale = new RawMatrix3x2();
+                inverseScale.M11 = 1.0f / PresentationParameters.SwapChainPanel.CompositionScaleX;
+                inverseScale.M22 = 1.0f / PresentationParameters.SwapChainPanel.CompositionScaleY;
+                using (var swapChain2 = _swapChain.QueryInterface<SwapChain2>())
+                    swapChain2.MatrixTransform = inverseScale;
+                });
+            }
+
+            // Obtain the backbuffer for this window which will be the final 3D rendertarget.
+            Point targetSize;
+            using (var backBuffer = SharpDX.Direct3D11.Texture2D.FromSwapChain<SharpDX.Direct3D11.Texture2D>(_swapChain, 0))
+            {
+                // Create a view interface on the rendertarget to use on bind.
+                _renderTargetView = new SharpDX.Direct3D11.RenderTargetView(_d3dDevice, backBuffer);
+
+                // Get the rendertarget dimensions for later.
+                var backBufferDesc = backBuffer.Description;
+                targetSize = new Point(backBufferDesc.Width, backBufferDesc.Height);
+            }
+
+            // Create the depth buffer if we need it.
+            if (PresentationParameters.DepthStencilFormat != DepthFormat.None)
+            {
+                var depthFormat = SharpDXHelper.ToFormat(PresentationParameters.DepthStencilFormat);
+
+                // Allocate a 2-D surface as the depth/stencil buffer.
+                using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(_d3dDevice, new SharpDX.Direct3D11.Texture2DDescription()
+                {
+                    Format = depthFormat,
+                    ArraySize = 1,
+                    MipLevels = 1,
+                    Width = targetSize.X,
+                    Height = targetSize.Y,
+                    SampleDescription = multisampleDesc,
+                    Usage = SharpDX.Direct3D11.ResourceUsage.Default,
+                    BindFlags = SharpDX.Direct3D11.BindFlags.DepthStencil,
+                }))
+
+                // Create a DepthStencil view on this surface to use on bind.
+                _depthStencilView = new SharpDX.Direct3D11.DepthStencilView(_d3dDevice, depthBuffer);
+            }
+
+            // Set the current viewport.
+            Viewport = new Viewport
+            { 
+                X = 0, 
+                Y = 0,
+                Width = targetSize.X, 
+                Height = targetSize.Y, 
+                MinDepth = 0.0f, 
+                MaxDepth = 1.0f 
+            };
+
+            // Now we set up the Direct2D render target bitmap linked to the swapchain. 
+            // Whenever we render to this bitmap, it will be directly rendered to the 
+            // swapchain associated with the window.
+            var bitmapProperties = new SharpDX.Direct2D1.BitmapProperties1(
+                new SharpDX.Direct2D1.PixelFormat(format, SharpDX.Direct2D1.AlphaMode.Premultiplied),
+                _dpi, _dpi,
+                SharpDX.Direct2D1.BitmapOptions.Target | SharpDX.Direct2D1.BitmapOptions.CannotDraw);
+            
+            // Direct2D needs the dxgi version of the backbuffer surface pointer.
+            // Get a D2D surface from the DXGI back buffer to use as the D2D render target.
+            using (var dxgiBackBuffer = _swapChain.GetBackBuffer<SharpDX.DXGI.Surface>(0))
+                _bitmapTarget = new SharpDX.Direct2D1.Bitmap1(_d2dContext, dxgiBackBuffer, bitmapProperties);
+
+            // So now we can set the Direct2D render target.
+            _d2dContext.Target = _bitmapTarget;
+
+            // Set D2D text anti-alias mode to Grayscale to 
+            // ensure proper rendering of text on intermediate surfaces.
+            _d2dContext.TextAntialiasMode = SharpDX.Direct2D1.TextAntialiasMode.Grayscale;
+        }
+
+        internal void OnPresentationChanged()
+        {
+            CreateSizeDependentResources();
+            ApplyRenderTargets(null);
+        }
+
+#endif
+
+        partial void PlatformReset()
+        {
+#if WINDOWS
+            CorrectBackBufferSize();
+#endif
+
+#if WINDOWS_UAP
+            if (PresentationParameters.DeviceWindowHandle == IntPtr.Zero && PresentationParameters.SwapChainPanel == null)
+                throw new ArgumentException("PresentationParameters.DeviceWindowHandle or PresentationParameters.SwapChainPanel must not be null.");
+#else
+            if (PresentationParameters.DeviceWindowHandle == IntPtr.Zero)
+                throw new ArgumentException("PresentationParameters.DeviceWindowHandle must not be null.");
+#endif
+        }
+
+#if  WINDOWS_UAP
+
+        private void SetMultiSamplingToMaximum(PresentationParameters presentationParameters, out int quality)
+        {
+            quality = (int)SharpDX.Direct3D11.StandardMultisampleQualityLevels.StandardMultisamplePattern;
+        }
+
+#endif
+#if WINDOWS
+
+        private void CorrectBackBufferSize()
+        {
+            // Window size can be modified when we're going full screen, we need to take that into account
+            // so the back buffer has the right size.
+            if (PresentationParameters.IsFullScreen)
+            {
+                int newWidth, newHeight;
+                if (PresentationParameters.HardwareModeSwitch)
+                    GetModeSwitchedSize(out newWidth, out newHeight);
+                else
+                    GetDisplayResolution(out newWidth, out newHeight);
+
+                PresentationParameters.BackBufferWidth = newWidth;
+                PresentationParameters.BackBufferHeight = newHeight;
+            }
+        }
+
+        /// <summary>
+        /// Create graphics device specific resources.
+        /// </summary>
+        protected virtual void CreateDeviceResources()
+        {
+            // Dispose previous references.
+            if (_d3dDevice != null)
+                _d3dDevice.Dispose();
+            if (_d3dContext != null)
+                _d3dContext.Dispose();
+
+            // Windows requires BGRA support out of DX.
+            var creationFlags = SharpDX.Direct3D11.DeviceCreationFlags.BgraSupport;
+
+            if (GraphicsAdapter.UseDebugLayers)
+            {
+                creationFlags |= SharpDX.Direct3D11.DeviceCreationFlags.Debug;
+            }
+
+            // Pass the preferred feature levels based on the
+            // target profile that may have been set by the user.
+            FeatureLevel[] featureLevels;
+            if (GraphicsProfile == GraphicsProfile.HiDef)
+            {
+                featureLevels = new[]
+                    {
+                        FeatureLevel.Level_11_0,
+                        FeatureLevel.Level_10_1,
+                        FeatureLevel.Level_10_0,
+                        // Feature levels below 10 are not supported for the HiDef profile
+                    };
+            }
+            else // Reach profile
+            {
+                featureLevels = new[]
+                    {
+                        // For the Reach profile, first try use the highest supported 9_X feature level
+                        FeatureLevel.Level_9_3,
+                        FeatureLevel.Level_9_2,
+                        FeatureLevel.Level_9_1,
+                        // If level 9 is not supported, then just use the highest supported level
+                        FeatureLevel.Level_11_0,
+                        FeatureLevel.Level_10_1,
+                        FeatureLevel.Level_10_0,
+                    };
+            }
+
+            var driverType = DriverType.Hardware;   //Default value
+            switch (GraphicsAdapter.UseDriverType)
+            {
+                case GraphicsAdapter.DriverType.Reference:
+                    driverType = DriverType.Reference;
+                    break;
+
+                case GraphicsAdapter.DriverType.FastSoftware:
+                    driverType = DriverType.Warp;
+                    break;
+            }
+            
+            try
+            {
+                // Create the Direct3D device.
+                using (var defaultDevice = new SharpDX.Direct3D11.Device(driverType, creationFlags, featureLevels))
+                    _d3dDevice = defaultDevice.QueryInterface<SharpDX.Direct3D11.Device>();
+            }
+            catch (SharpDXException)
+            {
+                // Try again without the debug flag.  This allows debug builds to run
+                // on machines that don't have the debug runtime installed.
+                creationFlags &= ~SharpDX.Direct3D11.DeviceCreationFlags.Debug;
+                using (var defaultDevice = new SharpDX.Direct3D11.Device(driverType, creationFlags, featureLevels))
+                    _d3dDevice = defaultDevice.QueryInterface<SharpDX.Direct3D11.Device>();
+            }
+
+            // Get Direct3D 11.1 context
+            _d3dContext = _d3dDevice.ImmediateContext.QueryInterface<SharpDX.Direct3D11.DeviceContext>();
+            
+            // Create a new instance of GraphicsDebug because we support it on Windows platforms.
+            _graphicsDebug = new GraphicsDebug(this);
+        }
+
+        internal void SetHardwareFullscreen()
+        {
+            _swapChain.SetFullscreenState(PresentationParameters.IsFullScreen && PresentationParameters.HardwareModeSwitch, null);
+        }
+
+        internal void ClearHardwareFullscreen()
+        {
+            _swapChain.SetFullscreenState(false, null);
+        }
+
+        internal void ResizeTargets()
+        {
+            var format = SharpDXHelper.ToFormat(PresentationParameters.BackBufferFormat);
+            var descr = new ModeDescription
+            {
+                Format = format,
+#if WINRT
+                Scaling = DisplayModeScaling.Stretched,
+#else
+                Scaling = DisplayModeScaling.Unspecified,
+#endif
+                Width = PresentationParameters.BackBufferWidth,
+                Height = PresentationParameters.BackBufferHeight,
+            };
+
+            _swapChain.ResizeTarget(ref descr);
+        }
+
+        internal void GetModeSwitchedSize(out int width, out int height)
+        {
+            Output output = null;
+            if (_swapChain == null)
+            {
+                // get the primary output
+                using (var factory = new SharpDX.DXGI.Factory1())
+                using (var adapter = factory.GetAdapter1(0))
+                    output = adapter.Outputs[0];
+            }
+            else
+            {
+                try
+                {
+                    output = _swapChain.ContainingOutput;
+                }
+                catch (SharpDXException) { /* ContainingOutput fails on a headless device */ }
+            }
+
+            var format = SharpDXHelper.ToFormat(PresentationParameters.BackBufferFormat);
+            var target = new ModeDescription
+            {
+                Format = format,
+#if WINRT
+                Scaling = DisplayModeScaling.Stretched,
+#else
+                Scaling = DisplayModeScaling.Unspecified,
+#endif
+                Width = PresentationParameters.BackBufferWidth,
+                Height = PresentationParameters.BackBufferHeight,
+            };
+
+            if (output == null)
+            {
+                width = PresentationParameters.BackBufferWidth;
+                height = PresentationParameters.BackBufferHeight;
+            }
+            else
+            {
+                ModeDescription closest;
+                output.GetClosestMatchingMode(_d3dDevice, target, out closest);
+                width = closest.Width;
+                height = closest.Height;
+                output.Dispose();
+            }
+        }
+
+        internal void GetDisplayResolution(out int width, out int height)
+        {
+            width = Adapter.CurrentDisplayMode.Width;
+            height = Adapter.CurrentDisplayMode.Height;
+        }
+
+        internal void CreateSizeDependentResources()
+        {
+            // Clamp MultiSampleCount
+            PresentationParameters.MultiSampleCount =
+                GetClampedMultisampleCount(PresentationParameters.MultiSampleCount);
+
+            _d3dContext.OutputMerger.SetTargets((SharpDX.Direct3D11.DepthStencilView)null,
+                                                (SharpDX.Direct3D11.RenderTargetView)null);
+
+            if (_renderTargetView != null)
+            {
+                _renderTargetView.Dispose();
+                _renderTargetView = null;
+            }
+            if (_depthStencilView != null)
+            {
+                _depthStencilView.Dispose();
+                _depthStencilView = null;
+            }
+
+            // Clear the current render targets.
+            _currentDepthStencilView = null;
+            Array.Clear(_currentRenderTargets, 0, _currentRenderTargets.Length);
+            Array.Clear(_currentRenderTargetBindings, 0, _currentRenderTargetBindings.Length);
+            _currentRenderTargetCount = 0;
+
+            // Make sure all pending rendering commands are flushed.
+            _d3dContext.Flush();
+
+            // We need presentation parameters to continue here.
+            if (PresentationParameters == null || PresentationParameters.DeviceWindowHandle == IntPtr.Zero)
+            {
+                if (_swapChain != null)
+                {
+                    _swapChain.Dispose();
+                    _swapChain = null;
+                }
+
+                return;
+            }
+
+            var format = SharpDXHelper.ToFormat(PresentationParameters.BackBufferFormat);
+            var multisampleDesc = GetSupportedSampleDescription(
+                format, 
+                PresentationParameters.MultiSampleCount);
+
+            // If the swap chain already exists... update it.
+            if (_swapChain != null
+                // check if multisampling hasn't changed
+                && _swapChain.Description.SampleDescription.Count == multisampleDesc.Count
+                && _swapChain.Description.SampleDescription.Quality == multisampleDesc.Quality)
+            {
+                _swapChain.ResizeBuffers(2,
+                                        PresentationParameters.BackBufferWidth,
+                                        PresentationParameters.BackBufferHeight,
+                                        format,
+                                        SwapChainFlags.AllowModeSwitch);
+            }
+
+            // Otherwise, create a new swap chain.
+            else
+            {
+                var wasFullScreen = false;
+                // Dispose of old swap chain if exists
+                if (_swapChain != null)
+                {
+                    wasFullScreen = _swapChain.IsFullScreen;
+                    // Before releasing a swap chain, first switch to windowed mode
+                    _swapChain.SetFullscreenState(false, null);
+                    _swapChain.Dispose();
+                }
+
+                // SwapChain description
+                var desc = new SharpDX.DXGI.SwapChainDescription()
+                {
+                    ModeDescription =
+                    {
+                        Format = format,
+#if WINDOWS_UAP
+                        Scaling = DisplayModeScaling.Stretched,
+#else
+                        Scaling = DisplayModeScaling.Unspecified,
+#endif
+                        Width = PresentationParameters.BackBufferWidth,
+                        Height = PresentationParameters.BackBufferHeight,
+                    },
+
+                    OutputHandle = PresentationParameters.DeviceWindowHandle,
+                    SampleDescription = multisampleDesc,
+                    Usage = SharpDX.DXGI.Usage.RenderTargetOutput,
+                    BufferCount = 2,
+                    SwapEffect = SharpDXHelper.ToSwapEffect(PresentationParameters.PresentationInterval),
+                    IsWindowed = true,
+                    Flags = SwapChainFlags.AllowModeSwitch
+                };
+
+                // Once the desired swap chain description is configured, it must be created on the same adapter as our D3D Device
+
+                // First, retrieve the underlying DXGI Device from the D3D Device.
+                // Creates the swap chain 
+                using (var dxgiDevice = _d3dDevice.QueryInterface<SharpDX.DXGI.Device1>())
+                using (var dxgiAdapter = dxgiDevice.Adapter)
+                using (var dxgiFactory = dxgiAdapter.GetParent<SharpDX.DXGI.Factory1>())
+                {
+                    _swapChain = new SwapChain(dxgiFactory, dxgiDevice, desc);
+                    RefreshAdapter();
+                    dxgiFactory.MakeWindowAssociation(PresentationParameters.DeviceWindowHandle, WindowAssociationFlags.IgnoreAll);
+                    // To reduce latency, ensure that DXGI does not queue more than one frame at a time.
+                    // Docs: https://msdn.microsoft.com/en-us/library/windows/desktop/ff471334(v=vs.85).aspx
+                    dxgiDevice.MaximumFrameLatency = 1;
+                }
+                // Preserve full screen state, after swap chain is re-created 
+                if (PresentationParameters.HardwareModeSwitch
+                    && wasFullScreen)
+                    SetHardwareFullscreen();
+            }
+
+            // Obtain the backbuffer for this window which will be the final 3D rendertarget.
+            Point targetSize;
+            using (var backBuffer = SharpDX.Direct3D11.Texture2D.FromSwapChain<SharpDX.Direct3D11.Texture2D>(_swapChain, 0))
+            {
+                // Create a view interface on the rendertarget to use on bind.
+                _renderTargetView = new SharpDX.Direct3D11.RenderTargetView(_d3dDevice, backBuffer);
+
+                // Get the rendertarget dimensions for later.
+                var backBufferDesc = backBuffer.Description;
+                targetSize = new Point(backBufferDesc.Width, backBufferDesc.Height);
+            }
+
+            // Create the depth buffer if we need it.
+            if (PresentationParameters.DepthStencilFormat != DepthFormat.None)
+            {
+                var depthFormat = SharpDXHelper.ToFormat(PresentationParameters.DepthStencilFormat);
+
+                // Allocate a 2-D surface as the depth/stencil buffer.
+                using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(_d3dDevice, new SharpDX.Direct3D11.Texture2DDescription()
+                {
+                    Format = depthFormat,
+                    ArraySize = 1,
+                    MipLevels = 1,
+                    Width = targetSize.X,
+                    Height = targetSize.Y,
+                    SampleDescription = multisampleDesc,
+                    Usage = SharpDX.Direct3D11.ResourceUsage.Default,
+                    BindFlags = SharpDX.Direct3D11.BindFlags.DepthStencil,
+                }))
+
+                    // Create a DepthStencil view on this surface to use on bind.
+                    _depthStencilView = new SharpDX.Direct3D11.DepthStencilView(_d3dDevice, depthBuffer);
+            }
+
+            // Set the current viewport.
+            Viewport = new Viewport
+            {
+                X = 0,
+                Y = 0,
+                Width = targetSize.X,
+                Height = targetSize.Y,
+                MinDepth = 0.0f,
+                MaxDepth = 1.0f
+            };
+        }
+
+        internal void RefreshAdapter()
+        {
+            if (_swapChain == null)
+                return;
+
+            Output output = null;
+            try
+            {
+                output = _swapChain.ContainingOutput;
+            }
+            catch (SharpDXException) { /* ContainingOutput fails on a headless device */ }
+
+            if (output != null)
+            {
+                foreach (var adapter in GraphicsAdapter.Adapters)
+                {
+                    if (adapter.DeviceName == output.Description.DeviceName)
+                    {
+                        Adapter = adapter;
+                        break;
+                    }
+                }
+
+                output.Dispose();
+            }
+        }
+
+        internal void OnPresentationChanged()
+        {
+            CreateSizeDependentResources();
+            ApplyRenderTargets(null);
+        }
+
+#endif // WINDOWS
+
+
+        /// <summary>
+        /// Get highest multisample quality level for specified format and multisample count.
+        /// Returns 0 if multisampling is not supported for input parameters.
+        /// </summary>
+        /// <param name="format">The texture format.</param>
+        /// <param name="multiSampleCount">The number of samples during multisampling.</param>
+        /// <returns>
+        /// Higher than zero if multiSampleCount is supported. 
+        /// Zero if multiSampleCount is not supported.
+        /// </returns>
+        private int GetMultiSamplingQuality(Format format, int multiSampleCount)
+        {
+            // The valid range is between zero and one less than the level returned by CheckMultisampleQualityLevels
+            // https://msdn.microsoft.com/en-us/library/windows/desktop/bb173072(v=vs.85).aspx
+            var quality = _d3dDevice.CheckMultisampleQualityLevels(format, multiSampleCount) - 1;
+            // NOTE: should we always return highest quality?
+            return Math.Max(quality, 0); // clamp minimum to 0 
+        }
+
+        internal SampleDescription GetSupportedSampleDescription(Format format, int multiSampleCount)
+        {
+            var multisampleDesc = new SharpDX.DXGI.SampleDescription(1, 0);
+
+            if (multiSampleCount > 1)
+            {
+                var quality = GetMultiSamplingQuality(format, multiSampleCount);
+
+                multisampleDesc.Count = multiSampleCount;
+                multisampleDesc.Quality = quality;
+            }
+
+            return multisampleDesc;
+        }
+
+        private void PlatformClear(ClearOptions options, Vector4 color, float depth, int stencil)
+        {
+            // Clear options for depth/stencil buffer if not attached.
+            if (_currentDepthStencilView != null)
+            {
+                if (_currentDepthStencilView.Description.Format != SharpDX.DXGI.Format.D24_UNorm_S8_UInt)
+                    options &= ~ClearOptions.Stencil;
+            }
+            else
+            {
+                options &= ~ClearOptions.DepthBuffer;
+                options &= ~ClearOptions.Stencil;
+            }
+
+            lock (_d3dContext)
+            {
+                // Clear the diffuse render buffer.
+                if ((options & ClearOptions.Target) == ClearOptions.Target)
+                {
+                    foreach (var view in _currentRenderTargets)
+                    {
+                        if (view != null)
+							_d3dContext.ClearRenderTargetView(view, new RawColor4(color.X, color.Y, color.Z, color.W));
+                    }
+                }
+
+                // Clear the depth/stencil render buffer.
+                SharpDX.Direct3D11.DepthStencilClearFlags flags = 0;
+                if ((options & ClearOptions.DepthBuffer) == ClearOptions.DepthBuffer)
+                    flags |= SharpDX.Direct3D11.DepthStencilClearFlags.Depth;
+                if ((options & ClearOptions.Stencil) == ClearOptions.Stencil)
+                    flags |= SharpDX.Direct3D11.DepthStencilClearFlags.Stencil;
+
+                if (flags != 0)
+                    _d3dContext.ClearDepthStencilView(_currentDepthStencilView, flags, depth, (byte)stencil);
+            }
+        }
+
+        private void PlatformDispose()
+        {
+            // make sure to release full screen or this might cause issues on exit
+            if (_swapChain.IsFullScreen)
+                _swapChain.SetFullscreenState(false, null);
+
+            SharpDX.Utilities.Dispose(ref _renderTargetView);
+            SharpDX.Utilities.Dispose(ref _depthStencilView);
+
+            if (_userIndexBuffer16 != null)
+                _userIndexBuffer16.Dispose();
+            if (_userIndexBuffer32 != null)
+                _userIndexBuffer32.Dispose();
+
+            foreach (var vb in _userVertexBuffers.Values)
+                vb.Dispose();
+
+            SharpDX.Utilities.Dispose(ref _swapChain);
+
+#if WINDOWS_UAP
+
+            if (_bitmapTarget != null)
+            {
+                _bitmapTarget.Dispose();
+                _depthStencilView = null;
+            }
+            if (_d2dDevice != null)
+            {
+                _d2dDevice.Dispose();
+                _d2dDevice = null;
+            }
+            if (_d2dContext != null)
+            {
+                _d2dContext.Target = null;
+                _d2dContext.Dispose();
+                _d2dContext = null;
+            }
+            if (_d2dFactory != null)
+            {
+                _d2dFactory.Dispose();
+                _d2dFactory = null;
+            }
+            if (_dwriteFactory != null)
+            {
+                _dwriteFactory.Dispose();
+                _dwriteFactory = null;
+            }
+            if (_wicFactory != null)
+            {
+                _wicFactory.Dispose();
+                _wicFactory = null;
+            }
+
+#endif
+
+            SharpDX.Utilities.Dispose(ref _d3dContext);
+            SharpDX.Utilities.Dispose(ref _d3dDevice);
+        }
+
+        private void PlatformPresent()
+        {
+#if WINDOWS_UAP
+            // The application may optionally specify "dirty" or "scroll" rects to improve efficiency
+            // in certain scenarios.  In this sample, however, we do not utilize those features.
+            var parameters = new SharpDX.DXGI.PresentParameters();
+            
+            try
+            {
+                // TODO: Hook in PresentationParameters here!
+
+                // The first argument instructs DXGI to block until VSync, putting the application
+                // to sleep until the next VSync. This ensures we don't waste any cycles rendering
+                // frames that will never be displayed to the screen.
+                lock (_d3dContext)
+                    _swapChain.Present(1, PresentFlags.None, parameters);
+            }
+            catch (SharpDX.SharpDXException)
+            {
+                // TODO: How should we deal with a device lost case here?
+                /*               
+                // If the device was removed either by a disconnect or a driver upgrade, we 
+                // must completely reinitialize the renderer.
+                if (    ex.ResultCode == SharpDX.DXGI.DXGIError.DeviceRemoved ||
+                        ex.ResultCode == SharpDX.DXGI.DXGIError.DeviceReset)
+                    this.Initialize();
+                else
+                    throw;
+                */
+            }
+
+#endif
+#if WINDOWS
+
+            try
+            {
+                var syncInterval = PresentationParameters.PresentationInterval.GetSyncInterval();
+
+                // The first argument instructs DXGI to block n VSyncs before presenting.
+                lock (_d3dContext)
+                    _swapChain.Present(syncInterval, PresentFlags.None);
+            }
+            catch (SharpDX.SharpDXException)
+            {
+                // TODO: How should we deal with a device lost case here?
+            }
+#endif
+        }
+
+        private void PlatformSetViewport(ref Viewport value)
+        {
+            if (_d3dContext != null)
+            {
+				var viewport = new RawViewportF
+				{
+					X = _viewport.X,
+					Y = _viewport.Y,
+					Width = (float)_viewport.Width,
+					Height = (float)_viewport.Height,
+					MinDepth = _viewport.MinDepth,
+					MaxDepth = _viewport.MaxDepth
+				};
+                lock (_d3dContext)
+                    _d3dContext.Rasterizer.SetViewport(viewport);
+            }
+        }
+
+        // Only implemented for DirectX right now, so not in GraphicsDevice.cs
+        public void SetRenderTarget(RenderTarget2D renderTarget, int arraySlice)
+        {
+            if (!GraphicsCapabilities.SupportsTextureArrays)
+                throw new InvalidOperationException("Texture arrays are not supported on this graphics device");
+
+            if (renderTarget == null)
+                SetRenderTarget(null);
+            else
+                SetRenderTargets(new RenderTargetBinding(renderTarget, arraySlice));
+        }
+
+        // Only implemented for DirectX right now, so not in GraphicsDevice.cs
+        public void SetRenderTarget(RenderTarget3D renderTarget, int arraySlice)
+        {
+            if (renderTarget == null)
+                SetRenderTarget(null);
+            else
+                SetRenderTargets(new RenderTargetBinding(renderTarget, arraySlice));
+        }
+
+        private void PlatformApplyDefaultRenderTarget()
+        {
+            // Set the default swap chain.
+            Array.Clear(_currentRenderTargets, 0, _currentRenderTargets.Length);
+            _currentRenderTargets[0] = _renderTargetView;
+            _currentDepthStencilView = _depthStencilView;
+
+            lock (_d3dContext)
+                _d3dContext.OutputMerger.SetTargets(_currentDepthStencilView, _currentRenderTargets);
+        }
+
+        internal void PlatformResolveRenderTargets()
+        {
+            for (var i = 0; i < _currentRenderTargetCount; i++)
+            {
+                var renderTargetBinding = _currentRenderTargetBindings[i];
+
+                // Resolve MSAA render targets
+                var renderTarget = renderTargetBinding.RenderTarget as RenderTarget2D;
+                if (renderTarget != null && renderTarget.MultiSampleCount > 1)
+                    renderTarget.ResolveSubresource();
+
+                // Generate mipmaps.
+                if (renderTargetBinding.RenderTarget.LevelCount > 1)
+                {
+                    lock (_d3dContext)
+                        _d3dContext.GenerateMips(renderTargetBinding.RenderTarget.GetShaderResourceView());
+                }
+            }
+        }
+
+        private IRenderTarget PlatformApplyRenderTargets()
+        {
+            // Clear the current render targets.
+            Array.Clear(_currentRenderTargets, 0, _currentRenderTargets.Length);
+            _currentDepthStencilView = null;
+
+            // Make sure none of the new targets are bound
+            // to the device as a texture resource.
+            lock (_d3dContext)
+            {
+                VertexTextures.ClearTargets(this, _currentRenderTargetBindings);
+                Textures.ClearTargets(this, _currentRenderTargetBindings);
+            }
+
+            for (var i = 0; i < _currentRenderTargetCount; i++)
+            {
+                var binding = _currentRenderTargetBindings[i];
+                var target = (IRenderTarget)binding.RenderTarget;
+                _currentRenderTargets[i] = target.GetRenderTargetView(binding.ArraySlice);
+            }
+
+            // Use the depth from the first target.
+            var renderTarget = (IRenderTarget)_currentRenderTargetBindings[0].RenderTarget;
+            _currentDepthStencilView = renderTarget.GetDepthStencilView();
+
+            // Set the targets.
+            lock (_d3dContext)
+                _d3dContext.OutputMerger.SetTargets(_currentDepthStencilView, _currentRenderTargets);
+
+            return renderTarget;
+        }
+
+#if WINDOWS_UAP
+        internal void ResetRenderTargets()
+        {
+            if (_d3dContext != null)
+            {
+                lock (_d3dContext)
+                {
+					var viewport = new RawViewportF
+					{
+						X = _viewport.X,
+						Y = _viewport.Y,
+						Width = _viewport.Width,
+						Height = _viewport.Height,
+						MinDepth = _viewport.MinDepth,
+						MaxDepth = _viewport.MaxDepth
+					};
+                    _d3dContext.Rasterizer.SetViewport(viewport);
+                    _d3dContext.OutputMerger.SetTargets(_currentDepthStencilView, _currentRenderTargets);
+                }
+            }
+
+            Textures.Dirty();
+            SamplerStates.Dirty();
+            _depthStencilStateDirty = true;
+            _blendStateDirty = true;
+            _indexBufferDirty = true;
+            _vertexBuffersDirty = true;
+            _pixelShaderDirty = true;
+            _vertexShaderDirty = true;
+            _rasterizerStateDirty = true;
+            _scissorRectangleDirty = true;            
+        }
+#endif
+
+        private static PrimitiveTopology ToPrimitiveTopology(PrimitiveType primitiveType)
+        {
+            switch (primitiveType)
+            {
+                case PrimitiveType.LineList:
+                    return PrimitiveTopology.LineList;
+                case PrimitiveType.LineStrip:
+                    return PrimitiveTopology.LineStrip;
+                case PrimitiveType.TriangleList:
+                    return PrimitiveTopology.TriangleList;
+                case PrimitiveType.TriangleStrip:
+                    return PrimitiveTopology.TriangleStrip;
+            }
+
+            throw new ArgumentException();
+        }
+
+        internal void PlatformBeginApplyState()
+        {
+            Debug.Assert(_d3dContext != null, "The d3d context is null!");
+        }
+
+        private void PlatformApplyBlend()
+        {
+            if (_blendFactorDirty || _blendStateDirty)
+            {
+                var state = _actualBlendState.GetDxState(this);
+                var factor = GetBlendFactor();
+                _d3dContext.OutputMerger.SetBlendState(state, factor);
+
+                _blendFactorDirty = false;
+                _blendStateDirty = false;
+            }
+        }
+
+        private SharpDX.Mathematics.Interop.RawColor4 GetBlendFactor()
+        {
+			return new SharpDX.Mathematics.Interop.RawColor4(
+					BlendFactor.R / 255.0f,
+					BlendFactor.G / 255.0f,
+					BlendFactor.B / 255.0f,
+					BlendFactor.A / 255.0f);
+        }
+
+        internal void PlatformApplyState(bool applyShaders)
+        {
+            // NOTE: This code assumes _d3dContext has been locked by the caller.
+
+            if (_scissorRectangleDirty)
+            {
+                _d3dContext.Rasterizer.SetScissorRectangle(
+                    _scissorRectangle.X,
+                    _scissorRectangle.Y,
+                    _scissorRectangle.Right,
+                    _scissorRectangle.Bottom);
+                _scissorRectangleDirty = false;
+            }
+
+            // If we're not applying shaders then early out now.
+            if (!applyShaders)
+                return;
+
+            if (_indexBufferDirty)
+            {
+                if (_indexBuffer != null)
+                {
+                    _d3dContext.InputAssembler.SetIndexBuffer(
+                        _indexBuffer.Buffer,
+                        _indexBuffer.IndexElementSize == IndexElementSize.SixteenBits ?
+                            SharpDX.DXGI.Format.R16_UInt : SharpDX.DXGI.Format.R32_UInt,
+                        0);
+                }
+                _indexBufferDirty = false;
+            }
+
+            if (_vertexBuffersDirty)
+            {
+                if (_vertexBuffers.Count > 0)
+                {
+                    for (int slot = 0; slot < _vertexBuffers.Count; slot++)
+                    {
+                        var vertexBufferBinding = _vertexBuffers.Get(slot);
+                        var vertexBuffer = vertexBufferBinding.VertexBuffer;
+                        var vertexDeclaration = vertexBuffer.VertexDeclaration;
+                        int vertexStride = vertexDeclaration.VertexStride;
+                        int vertexOffsetInBytes = vertexBufferBinding.VertexOffset * vertexStride;
+                        _d3dContext.InputAssembler.SetVertexBuffers(
+                            slot, new SharpDX.Direct3D11.VertexBufferBinding(vertexBuffer.Buffer, vertexStride, vertexOffsetInBytes));
+                    }
+                    _vertexBufferSlotsUsed = _vertexBuffers.Count;
+                }
+                else
+                {
+                    for (int slot = 0; slot < _vertexBufferSlotsUsed; slot++)
+                        _d3dContext.InputAssembler.SetVertexBuffers(slot, new SharpDX.Direct3D11.VertexBufferBinding());
+
+                    _vertexBufferSlotsUsed = 0;
+                }
+            }
+
+            if (_vertexShader == null)
+                throw new InvalidOperationException("A vertex shader must be set!");
+            if (_pixelShader == null)
+                throw new InvalidOperationException("A pixel shader must be set!");
+
+            if (_vertexShaderDirty)
+            {
+                _d3dContext.VertexShader.Set(_vertexShader.VertexShader);
+
+                unchecked
+                {
+                    _graphicsMetrics._vertexShaderCount++;
+                }
+            }
+            if (_vertexShaderDirty || _vertexBuffersDirty)
+            {
+                _d3dContext.InputAssembler.InputLayout = _vertexShader.InputLayouts.GetOrCreate(_vertexBuffers);
+                _vertexShaderDirty = _vertexBuffersDirty = false;
+            }
+
+            if (_pixelShaderDirty)
+            {
+                _d3dContext.PixelShader.Set(_pixelShader.PixelShader);
+                _pixelShaderDirty = false;
+
+                unchecked
+                {
+                    _graphicsMetrics._pixelShaderCount++;
+                }
+            }
+
+            _vertexConstantBuffers.SetConstantBuffers(this);
+            _pixelConstantBuffers.SetConstantBuffers(this);
+
+            VertexTextures.SetTextures(this);
+            VertexSamplerStates.PlatformSetSamplers(this);
+            Textures.SetTextures(this);
+            SamplerStates.PlatformSetSamplers(this);
+        }
+
+        private int SetUserVertexBuffer<T>(T[] vertexData, int vertexOffset, int vertexCount, VertexDeclaration vertexDecl)
+            where T : struct
+        {
+            DynamicVertexBuffer buffer;
+
+            if (!_userVertexBuffers.TryGetValue(vertexDecl, out buffer) || buffer.VertexCount < vertexCount)
+            {
+                // Dispose the previous buffer if we have one.
+                if (buffer != null)
+                    buffer.Dispose();
+
+                buffer = new DynamicVertexBuffer(this, vertexDecl, Math.Max(vertexCount, 2000), BufferUsage.WriteOnly);
+                _userVertexBuffers[vertexDecl] = buffer;
+            }
+
+            var startVertex = buffer.UserOffset;
+
+
+            if ((vertexCount + buffer.UserOffset) < buffer.VertexCount)
+            {
+                buffer.UserOffset += vertexCount;
+                buffer.SetData(startVertex * vertexDecl.VertexStride, vertexData, vertexOffset, vertexCount, vertexDecl.VertexStride, SetDataOptions.NoOverwrite);
+            }
+            else
+            {
+                buffer.UserOffset = vertexCount;
+                buffer.SetData(vertexData, vertexOffset, vertexCount, SetDataOptions.Discard);
+                startVertex = 0;
+            }
+
+            SetVertexBuffer(buffer);
+
+            return startVertex;
+        }
+
+        private int SetUserIndexBuffer<T>(T[] indexData, int indexOffset, int indexCount)
+            where T : struct
+        {
+            DynamicIndexBuffer buffer;
+
+            var indexSize = ReflectionHelpers.SizeOf<T>.Get();
+            var indexElementSize = indexSize == 2 ? IndexElementSize.SixteenBits : IndexElementSize.ThirtyTwoBits;
+
+            var requiredIndexCount = Math.Max(indexCount, 6000);
+            if (indexElementSize == IndexElementSize.SixteenBits)
+            {
+                if (_userIndexBuffer16 == null || _userIndexBuffer16.IndexCount < requiredIndexCount)
+                {
+                    if (_userIndexBuffer16 != null)
+                        _userIndexBuffer16.Dispose();
+
+                    _userIndexBuffer16 = new DynamicIndexBuffer(this, indexElementSize, requiredIndexCount, BufferUsage.WriteOnly);
+                }
+
+                buffer = _userIndexBuffer16;
+            }
+            else
+            {
+                if (_userIndexBuffer32 == null || _userIndexBuffer32.IndexCount < requiredIndexCount)
+                {
+                    if (_userIndexBuffer32 != null)
+                        _userIndexBuffer32.Dispose();
+
+                    _userIndexBuffer32 = new DynamicIndexBuffer(this, indexElementSize, requiredIndexCount, BufferUsage.WriteOnly);
+                }
+
+                buffer = _userIndexBuffer32;                
+            }
+
+            var startIndex = buffer.UserOffset;
+
+            if ((indexCount + buffer.UserOffset) < buffer.IndexCount)
+            {
+                buffer.UserOffset += indexCount;
+                buffer.SetData(startIndex * indexSize, indexData, indexOffset, indexCount, SetDataOptions.NoOverwrite);
+            }
+            else
+            {
+                startIndex = 0;
+                buffer.UserOffset = indexCount;
+                buffer.SetData(indexData, indexOffset, indexCount, SetDataOptions.Discard);
+            }
+
+            Indices = buffer;
+
+            return startIndex;
+        }
+
+        private void PlatformDrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int startIndex, int primitiveCount)
+        {
+            lock (_d3dContext)
+            {
+                ApplyState(true);
+
+                _d3dContext.InputAssembler.PrimitiveTopology = ToPrimitiveTopology(primitiveType);
+
+                var indexCount = GetElementCountArray(primitiveType, primitiveCount);
+                _d3dContext.DrawIndexed(indexCount, startIndex, baseVertex);
+            }
+        }
+
+        private void PlatformDrawUserPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, VertexDeclaration vertexDeclaration, int vertexCount) where T : struct
+        {
+            var startVertex = SetUserVertexBuffer(vertexData, vertexOffset, vertexCount, vertexDeclaration);
+
+            lock (_d3dContext)
+            {
+                ApplyState(true);
+
+                _d3dContext.InputAssembler.PrimitiveTopology = ToPrimitiveTopology(primitiveType);
+                _d3dContext.Draw(vertexCount, startVertex);
+            }
+        }
+
+        private void PlatformDrawPrimitives(PrimitiveType primitiveType, int vertexStart, int vertexCount)
+        {
+            lock (_d3dContext)
+            {
+                ApplyState(true);
+
+                _d3dContext.InputAssembler.PrimitiveTopology = ToPrimitiveTopology(primitiveType);
+                _d3dContext.Draw(vertexCount, vertexStart);
+            }
+        }
+
+        private void PlatformDrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices, short[] indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration) where T : struct
+        {
+            var indexCount = GetElementCountArray(primitiveType, primitiveCount);
+            var startVertex = SetUserVertexBuffer(vertexData, vertexOffset, numVertices, vertexDeclaration);
+            var startIndex = SetUserIndexBuffer(indexData, indexOffset, indexCount);
+
+            lock (_d3dContext)
+            {
+                ApplyState(true);
+
+                _d3dContext.InputAssembler.PrimitiveTopology = ToPrimitiveTopology(primitiveType);
+                _d3dContext.DrawIndexed(indexCount, startIndex, startVertex);
+            }
+        }
+
+        private void PlatformDrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices, int[] indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration) where T : struct
+        {
+            var indexCount = GetElementCountArray(primitiveType, primitiveCount);
+            var startVertex = SetUserVertexBuffer(vertexData, vertexOffset, numVertices, vertexDeclaration);
+            var startIndex = SetUserIndexBuffer(indexData, indexOffset, indexCount);
+
+            lock (_d3dContext)
+            {
+                ApplyState(true);
+
+                _d3dContext.InputAssembler.PrimitiveTopology = ToPrimitiveTopology(primitiveType);
+                _d3dContext.DrawIndexed(indexCount, startIndex, startVertex);
+            }
+        }
+
+        private void PlatformDrawInstancedPrimitives(PrimitiveType primitiveType, int baseVertex, int startIndex,
+            int primitiveCount, int instanceCount)
+        {
+            lock (_d3dContext)
+            {
+                ApplyState(true);
+
+                _d3dContext.InputAssembler.PrimitiveTopology = ToPrimitiveTopology(primitiveType);
+                int indexCount = GetElementCountArray(primitiveType, primitiveCount);
+                _d3dContext.DrawIndexedInstanced(indexCount, instanceCount, startIndex, baseVertex, 0);
+            }
+        }
+
+        private void PlatformGetBackBufferData<T>(Rectangle? rect, T[] data, int startIndex, int count) where T : struct
+        {
+            // TODO share code with Texture2D.GetData and do pooling for staging textures
+            // first set up a staging texture
+            const SurfaceFormat format = SurfaceFormat.Color;
+            //You can't Map the BackBuffer surface, so we copy to another texture
+            using (var backBufferTexture = SharpDX.Direct3D11.Resource.FromSwapChain<SharpDX.Direct3D11.Texture2D>(_swapChain, 0))
+            {
+                var desc = backBufferTexture.Description;
+                desc.SampleDescription = new SampleDescription(1, 0);
+                desc.BindFlags = BindFlags.None;
+                desc.CpuAccessFlags = CpuAccessFlags.Read;
+                desc.Usage = ResourceUsage.Staging;
+                desc.OptionFlags = ResourceOptionFlags.None;
+
+                using (var stagingTex = new SharpDX.Direct3D11.Texture2D(_d3dDevice, desc))
+                {
+                    lock (_d3dContext)
+                    {
+                        // Copy the data from the GPU to the staging texture.
+                        // if MSAA is enabled we need to first copy to a resource without MSAA
+                        if (backBufferTexture.Description.SampleDescription.Count > 1)
+                        {
+                            desc.Usage = ResourceUsage.Default;
+                            desc.CpuAccessFlags = CpuAccessFlags.None;
+                            using (var noMsTex = new SharpDX.Direct3D11.Texture2D(_d3dDevice, desc))
+                            {
+                                _d3dContext.ResolveSubresource(backBufferTexture, 0, noMsTex, 0, desc.Format);
+                                if (rect.HasValue)
+                                {
+                                    var r = rect.Value;
+                                    _d3dContext.CopySubresourceRegion(noMsTex, 0,
+                                        new ResourceRegion(r.Left, r.Top, 0, r.Right, r.Bottom, 1), stagingTex,
+                                        0);
+                                }
+                                else
+                                    _d3dContext.CopyResource(noMsTex, stagingTex);
+                            }
+                        }
+                        else
+                        {
+                            if (rect.HasValue)
+                            {
+                                var r = rect.Value;
+                                _d3dContext.CopySubresourceRegion(backBufferTexture, 0,
+                                    new ResourceRegion(r.Left, r.Top, 0, r.Right, r.Bottom, 1), stagingTex, 0);
+                            }
+                            else
+                                _d3dContext.CopyResource(backBufferTexture, stagingTex);
+                        }
+
+                        // Copy the data to the array.
+                        DataStream stream = null;
+                        try
+                        {
+                            var databox = _d3dContext.MapSubresource(stagingTex, 0, MapMode.Read, SharpDX.Direct3D11.MapFlags.None, out stream);
+
+                            int elementsInRow, rows;
+                            if (rect.HasValue)
+                            {
+                                elementsInRow = rect.Value.Width;
+                                rows = rect.Value.Height;
+                            }
+                            else
+                            {
+                                elementsInRow = stagingTex.Description.Width;
+                                rows = stagingTex.Description.Height;
+                            }
+                            var elementSize = format.GetSize();
+                            var rowSize = elementSize * elementsInRow;
+                            if (rowSize == databox.RowPitch)
+                                stream.ReadRange(data, startIndex, count);
+                            else
+                            {
+                                // Some drivers may add pitch to rows.
+                                // We need to copy each row separately and skip trailing zeroes.
+                                stream.Seek(0, SeekOrigin.Begin);
+
+                                var elementSizeInByte = ReflectionHelpers.SizeOf<T>.Get();
+                                for (var row = 0; row < rows; row++)
+                                {
+                                    int i;
+                                    for (i = row * rowSize / elementSizeInByte; i < (row + 1) * rowSize / elementSizeInByte; i++)
+                                        data[i + startIndex] = stream.Read<T>();
+
+                                    if (i >= count)
+                                        break;
+
+                                    stream.Seek(databox.RowPitch - rowSize, SeekOrigin.Current);
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            SharpDX.Utilities.Dispose( ref stream);
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Sends queued-up commands in the command buffer to the graphics processing unit (GPU).
+        /// </summary>
+        public void Flush()
+        {
+            _d3dContext.Flush();
+        }
+
+#if WINDOWS_UAP
+        internal void Trim()
+        {
+            using (var dxgiDevice3 = _d3dDevice.QueryInterface<SharpDX.DXGI.Device3>())
+                dxgiDevice3.Trim();
+        }
+#endif
+
+        private static Rectangle PlatformGetTitleSafeArea(int x, int y, int width, int height)
+        {
+            return new Rectangle(x, y, width, height);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsDevice.OpenGL.FramebufferHelper.cs b/MonoGame.Framework/Graphics/GraphicsDevice.OpenGL.FramebufferHelper.cs
new file mode 100644
index 00000000000..6b953e8c9dd
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsDevice.OpenGL.FramebufferHelper.cs
@@ -0,0 +1,175 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using MonoGame.OpenGL;
+
+using System.Security;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    // ARB_framebuffer_object implementation
+    partial class GraphicsDevice
+    {
+        internal class FramebufferHelper
+        {
+            private static FramebufferHelper _instance;
+
+            public static FramebufferHelper Create(GraphicsDevice gd)
+            {
+                if (gd.GraphicsCapabilities.SupportsFramebufferObjectARB || gd.GraphicsCapabilities.SupportsFramebufferObjectEXT)
+                {
+                    _instance = new FramebufferHelper(gd);
+                }
+                else
+                {
+                    throw new PlatformNotSupportedException(
+                        "MonoGame requires either ARB_framebuffer_object or EXT_framebuffer_object." +
+                        "Try updating your graphics drivers.");
+                }
+
+                return _instance;
+            }
+
+            public static FramebufferHelper Get()
+            {
+                if (_instance == null)
+                    throw new InvalidOperationException("The FramebufferHelper has not been created yet!");
+                return _instance;
+            }
+
+            public bool SupportsInvalidateFramebuffer { get; private set; }
+
+            public bool SupportsBlitFramebuffer { get; private set; }
+
+            internal FramebufferHelper(GraphicsDevice graphicsDevice)
+            {
+                this.SupportsBlitFramebuffer = GL.BlitFramebuffer != null;
+                this.SupportsInvalidateFramebuffer = GL.InvalidateFramebuffer != null;
+            }
+
+            internal virtual void GenRenderbuffer(out int renderbuffer)
+            {
+                GL.GenRenderbuffers(1, out renderbuffer);
+                GraphicsExtensions.CheckGLError();
+            }
+
+            internal virtual void BindRenderbuffer(int renderbuffer)
+            {
+                GL.BindRenderbuffer(RenderbufferTarget.Renderbuffer, renderbuffer);
+                GraphicsExtensions.CheckGLError();
+            }
+
+            internal virtual void DeleteRenderbuffer(int renderbuffer)
+            {
+                GL.DeleteRenderbuffers(1, ref renderbuffer);
+                GraphicsExtensions.CheckGLError();
+            }
+
+            internal virtual void RenderbufferStorageMultisample(int samples, int internalFormat, int width, int height)
+            {
+                if (samples > 0 && GL.RenderbufferStorageMultisample != null)
+                    GL.RenderbufferStorageMultisample(RenderbufferTarget.RenderbufferExt, samples, (RenderbufferStorage)internalFormat, width, height);
+                else
+                    GL.RenderbufferStorage(RenderbufferTarget.Renderbuffer, (RenderbufferStorage)internalFormat, width, height);
+                GraphicsExtensions.CheckGLError();
+            }
+
+            internal virtual void GenFramebuffer(out int framebuffer)
+            {
+                GL.GenFramebuffers(1, out framebuffer);
+                GraphicsExtensions.CheckGLError();
+            }
+
+            internal virtual void BindFramebuffer(int framebuffer)
+            {
+                GL.BindFramebuffer(FramebufferTarget.Framebuffer, framebuffer);
+                GraphicsExtensions.CheckGLError();
+            }
+
+            internal virtual void BindReadFramebuffer(int readFramebuffer)
+            {
+                GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, readFramebuffer);
+                GraphicsExtensions.CheckGLError();
+            }
+
+            static readonly FramebufferAttachment [] FramebufferAttachements = {
+                FramebufferAttachment.ColorAttachment0,
+                FramebufferAttachment.DepthAttachment,
+                FramebufferAttachment.StencilAttachment,
+            };
+
+            internal virtual void InvalidateDrawFramebuffer()
+            {
+                Debug.Assert(this.SupportsInvalidateFramebuffer);
+                GL.InvalidateFramebuffer (FramebufferTarget.Framebuffer, 3, FramebufferAttachements);
+            }
+
+            internal virtual void InvalidateReadFramebuffer()
+            {
+                Debug.Assert(this.SupportsInvalidateFramebuffer);
+                GL.InvalidateFramebuffer(FramebufferTarget.Framebuffer, 3, FramebufferAttachements);
+            }
+
+            internal virtual void DeleteFramebuffer(int framebuffer)
+            {
+                GL.DeleteFramebuffers(1, ref framebuffer);
+                GraphicsExtensions.CheckGLError();
+            }
+
+            internal virtual void FramebufferTexture2D(int attachement, int target, int texture, int level = 0, int samples = 0)
+            {
+                GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, (FramebufferAttachment)attachement, (TextureTarget)target, texture, level);
+                GraphicsExtensions.CheckGLError();
+            }
+
+            internal virtual void FramebufferRenderbuffer(int attachement, int renderbuffer, int level = 0)
+            {
+                GL.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, (FramebufferAttachment)attachement, RenderbufferTarget.Renderbuffer, renderbuffer);
+                GraphicsExtensions.CheckGLError();
+            }
+
+            internal virtual void GenerateMipmap(int target)
+            {
+                GL.GenerateMipmap((GenerateMipmapTarget)target);
+                GraphicsExtensions.CheckGLError();
+
+            }
+
+            internal virtual void BlitFramebuffer(int iColorAttachment, int width, int height)
+            {
+
+                GL.ReadBuffer(ReadBufferMode.ColorAttachment0 + iColorAttachment);
+                GraphicsExtensions.CheckGLError();
+                GL.DrawBuffer(DrawBufferMode.ColorAttachment0 + iColorAttachment);
+                GraphicsExtensions.CheckGLError();
+                GL.BlitFramebuffer(0, 0, width, height, 0, 0, width, height, ClearBufferMask.ColorBufferBit, BlitFramebufferFilter.Nearest);
+                GraphicsExtensions.CheckGLError();
+
+            }
+
+            internal virtual void CheckFramebufferStatus()
+            {
+                var status = GL.CheckFramebufferStatus(FramebufferTarget.Framebuffer);
+                if (status != FramebufferErrorCode.FramebufferComplete)
+                {
+                    string message = "Framebuffer Incomplete.";
+                    switch (status)
+                    {
+                        case FramebufferErrorCode.FramebufferIncompleteAttachment: message = "Not all framebuffer attachment points are framebuffer attachment complete."; break;
+                        case FramebufferErrorCode.FramebufferIncompleteMissingAttachment: message = "No images are attached to the framebuffer."; break;
+                        case FramebufferErrorCode.FramebufferUnsupported: message = "The combination of internal formats of the attached images violates an implementation-dependent set of restrictions."; break;
+                        case FramebufferErrorCode.FramebufferIncompleteMultisample: message = "Not all attached images have the same number of samples."; break;
+                    }
+                    throw new InvalidOperationException(message);
+                }
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsDevice.OpenGL.cs b/MonoGame.Framework/Graphics/GraphicsDevice.OpenGL.cs
new file mode 100644
index 00000000000..d25a40f92c8
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsDevice.OpenGL.cs
@@ -0,0 +1,1284 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+
+#if ANGLE
+using OpenTK.Graphics;
+#else
+using MonoGame.OpenGL;
+#endif
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class GraphicsDevice
+    {
+#if DESKTOPGL || ANGLE
+        internal IGraphicsContext Context { get; private set; }
+#endif
+
+#if !GLES
+        private DrawBuffersEnum[] _drawBuffers;
+#endif
+
+        enum ResourceType
+        {
+            Texture,
+            Buffer,
+            Shader,
+            Program,
+            Query,
+            Framebuffer
+        }
+
+        struct ResourceHandle
+        {
+            public ResourceType type;
+            public int handle;
+
+            public static ResourceHandle Texture(int handle)
+            {
+                return new ResourceHandle() { type = ResourceType.Texture, handle = handle };
+            }
+
+            public static ResourceHandle Buffer(int handle)
+            {
+                return new ResourceHandle() { type = ResourceType.Buffer, handle = handle };
+            }
+
+            public static ResourceHandle Shader(int handle)
+            {
+                return new ResourceHandle() { type = ResourceType.Shader, handle = handle };
+            }
+
+            public static ResourceHandle Program(int handle)
+            {
+                return new ResourceHandle() { type = ResourceType.Program, handle = handle };
+            }
+
+            public static ResourceHandle Query(int handle)
+            {
+                return new ResourceHandle() { type = ResourceType.Query, handle = handle };
+            }
+
+            public static ResourceHandle Framebuffer(int handle)
+            {
+                return new ResourceHandle() { type = ResourceType.Framebuffer, handle = handle };
+            }
+
+            public void Free()
+            {
+                switch (type)
+                {
+                    case ResourceType.Texture:
+                        GL.DeleteTextures(1, ref handle);
+                        break;
+                    case ResourceType.Buffer:
+                        GL.DeleteBuffers(1, ref handle);
+                        break;
+                    case ResourceType.Shader:
+                        if (GL.IsShader(handle))
+                            GL.DeleteShader(handle);
+                        break;
+                    case ResourceType.Program:
+                        if (GL.IsProgram(handle))
+                        {
+                            GL.DeleteProgram(handle);
+                        }
+                        break;
+                    case ResourceType.Query:
+#if !GLES
+                        GL.DeleteQueries(1, ref handle);
+#endif
+                        break;
+                    case ResourceType.Framebuffer:
+                        GL.DeleteFramebuffers(1, ref handle);
+                        break;
+                }
+                GraphicsExtensions.CheckGLError();
+            }
+        }
+
+        List<ResourceHandle> _disposeThisFrame = new List<ResourceHandle>();
+        List<ResourceHandle> _disposeNextFrame = new List<ResourceHandle>();
+        object _disposeActionsLock = new object();
+
+        static List<IntPtr> _disposeContexts = new List<IntPtr>();
+        static object _disposeContextsLock = new object();
+
+        private ShaderProgramCache _programCache;
+        private ShaderProgram _shaderProgram = null;
+
+        static readonly float[] _posFixup = new float[4];
+
+        private static BufferBindingInfo[] _bufferBindingInfos;
+        private static bool[] _newEnabledVertexAttributes;
+        internal static readonly List<int> _enabledVertexAttributes = new List<int>();
+        internal static bool _attribsDirty;
+
+        internal FramebufferHelper framebufferHelper;
+
+        internal int glMajorVersion = 0;
+        internal int glMinorVersion = 0;
+        internal int glFramebuffer = 0;
+        internal int MaxVertexAttributes;
+        internal int _maxTextureSize = 0;
+
+        // Keeps track of last applied state to avoid redundant OpenGL calls
+        internal bool _lastBlendEnable = false;
+        internal BlendState _lastBlendState = new BlendState();
+        internal DepthStencilState _lastDepthStencilState = new DepthStencilState();
+        internal RasterizerState _lastRasterizerState = new RasterizerState();
+        private Vector4 _lastClearColor = Vector4.Zero;
+        private float _lastClearDepth = 1.0f;
+        private int _lastClearStencil = 0;
+
+        // Get a hashed value based on the currently bound shaders
+        // throws an exception if no shaders are bound
+        private int ShaderProgramHash
+        {
+            get
+            {
+                if (_vertexShader == null && _pixelShader == null)
+                    throw new InvalidOperationException("There is no shader bound!");
+                if (_vertexShader == null)
+                    return _pixelShader.HashKey;
+                if (_pixelShader == null)
+                    return _vertexShader.HashKey;
+                return _vertexShader.HashKey ^ _pixelShader.HashKey;
+            }
+        }
+
+        internal void SetVertexAttributeArray(bool[] attrs)
+        {
+            for (var x = 0; x < attrs.Length; x++)
+            {
+                if (attrs[x] && !_enabledVertexAttributes.Contains(x))
+                {
+                    _enabledVertexAttributes.Add(x);
+                    GL.EnableVertexAttribArray(x);
+                    GraphicsExtensions.CheckGLError();
+                }
+                else if (!attrs[x] && _enabledVertexAttributes.Contains(x))
+                {
+                    _enabledVertexAttributes.Remove(x);
+                    GL.DisableVertexAttribArray(x);
+                    GraphicsExtensions.CheckGLError();
+                }
+            }
+        }
+
+        private void ApplyAttribs(Shader shader, int baseVertex)
+        {
+            var programHash = ShaderProgramHash;
+            var bindingsChanged = false;
+
+            for (var slot = 0; slot < _vertexBuffers.Count; slot++)
+            {
+                var vertexBufferBinding = _vertexBuffers.Get(slot);
+                var vertexDeclaration = vertexBufferBinding.VertexBuffer.VertexDeclaration;
+                var attrInfo = vertexDeclaration.GetAttributeInfo(shader, programHash);
+
+                var vertexStride = vertexDeclaration.VertexStride;
+                var offset = (IntPtr)(vertexDeclaration.VertexStride * (baseVertex + vertexBufferBinding.VertexOffset));
+
+                if (!_attribsDirty &&
+                    _bufferBindingInfos[slot].VertexOffset == offset &&
+                    ReferenceEquals(_bufferBindingInfos[slot].AttributeInfo, attrInfo) &&
+                    _bufferBindingInfos[slot].InstanceFrequency == vertexBufferBinding.InstanceFrequency &&
+                    _bufferBindingInfos[slot].Vbo == vertexBufferBinding.VertexBuffer.vbo)
+                    continue;
+
+                bindingsChanged = true;
+
+                GL.BindBuffer(BufferTarget.ArrayBuffer, vertexBufferBinding.VertexBuffer.vbo);
+                GraphicsExtensions.CheckGLError();
+
+                // If instancing is not supported, but InstanceFrequency of the buffer is not zero, throw an exception
+                if (!GraphicsCapabilities.SupportsInstancing && vertexBufferBinding.InstanceFrequency > 0)
+                    throw new PlatformNotSupportedException("Instanced geometry drawing requires at least OpenGL 3.2 or GLES 3.2. Try upgrading your graphics drivers.");
+
+                foreach (var element in attrInfo.Elements)
+                {
+                    GL.VertexAttribPointer(element.AttributeLocation,
+                        element.NumberOfElements,
+                        element.VertexAttribPointerType,
+                        element.Normalized,
+                        vertexStride,
+                        (IntPtr)(offset.ToInt64() + element.Offset));
+
+                    // only set the divisor if instancing is supported
+                    if (GraphicsCapabilities.SupportsInstancing) 
+                        GL.VertexAttribDivisor(element.AttributeLocation, vertexBufferBinding.InstanceFrequency);
+
+                    GraphicsExtensions.CheckGLError();
+                }
+
+                _bufferBindingInfos[slot].VertexOffset = offset;
+                _bufferBindingInfos[slot].AttributeInfo = attrInfo;
+                _bufferBindingInfos[slot].InstanceFrequency = vertexBufferBinding.InstanceFrequency;
+                _bufferBindingInfos[slot].Vbo = vertexBufferBinding.VertexBuffer.vbo;
+            }
+
+            _attribsDirty = false;
+
+            if (bindingsChanged)
+            {
+                Array.Clear(_newEnabledVertexAttributes, 0, _newEnabledVertexAttributes.Length);
+                for (var slot = 0; slot < _vertexBuffers.Count; slot++)
+                {
+                    foreach (var element in _bufferBindingInfos[slot].AttributeInfo.Elements)
+                        _newEnabledVertexAttributes[element.AttributeLocation] = true;
+                }
+            }
+            SetVertexAttributeArray(_newEnabledVertexAttributes);
+        }
+
+        private void PlatformSetup()
+        {
+            _programCache = new ShaderProgramCache(this);
+#if DESKTOPGL || ANGLE
+            var windowInfo = new WindowInfo(SdlGameWindow.Instance.Handle);
+
+            if (Context == null || Context.IsDisposed)
+            {
+                Context = GL.CreateContext(windowInfo);
+            }
+
+            Context.MakeCurrent(windowInfo);
+            Context.SwapInterval = PresentationParameters.PresentationInterval.GetSwapInterval();
+
+            Context.MakeCurrent(windowInfo);
+#endif
+            MaxTextureSlots = 16;
+
+            GL.GetInteger(GetPName.MaxTextureImageUnits, out MaxTextureSlots);
+            GraphicsExtensions.CheckGLError();
+
+            GL.GetInteger(GetPName.MaxTextureSize, out _maxTextureSize);
+            GraphicsExtensions.CheckGLError();
+
+            GL.GetInteger(GetPName.MaxVertexAttribs, out MaxVertexAttributes);
+            GraphicsExtensions.CheckGLError();
+
+            _maxVertexBufferSlots = MaxVertexAttributes;
+            _newEnabledVertexAttributes = new bool[MaxVertexAttributes];
+
+
+            SpriteBatch.NeedsHalfPixelOffset = true;
+
+            // try getting the context version
+            // GL_MAJOR_VERSION and GL_MINOR_VERSION are GL 3.0+ only, so we need to rely on the GL_VERSION string
+            // for non GLES this string always starts with the version number in the "major.minor" format, but can be followed by
+            // multiple vendor specific characters
+            // For GLES this string is formatted as: OpenGL<space>ES<space><version number><space><vendor-specific information>
+#if GLES
+            try
+            {
+                string version = GL.GetString(StringName.Version);
+
+                if (string.IsNullOrEmpty(version))
+                    throw new NoSuitableGraphicsDeviceException("Unable to retrieve OpenGL version");
+
+                string[] versionSplit = version.Split(' ');
+                if (versionSplit.Length > 2 && versionSplit[0].Equals("OpenGL") && versionSplit[1].Equals("ES"))
+                {
+                    glMajorVersion = Convert.ToInt32(versionSplit[2].Substring(0, 1));
+                    glMinorVersion = Convert.ToInt32(versionSplit[2].Substring(2, 1));
+                }
+                else
+                {
+                    glMajorVersion = 1;
+                    glMinorVersion = 1;
+                }
+            }
+            catch (FormatException)
+            {
+                //if it fails we default to 1.1 context
+                glMajorVersion = 1;
+                glMinorVersion = 1;
+            }
+#else
+                try
+            {
+                string version = GL.GetString(StringName.Version);
+
+                if (string.IsNullOrEmpty(version))
+                    throw new NoSuitableGraphicsDeviceException("Unable to retrieve OpenGL version");
+
+                glMajorVersion = Convert.ToInt32(version.Substring(0, 1));
+                glMinorVersion = Convert.ToInt32(version.Substring(2, 1));
+            }
+            catch (FormatException)
+            {
+                // if it fails, we assume to be on a 1.1 context
+                glMajorVersion = 1;
+                glMinorVersion = 1;
+            }
+#endif
+
+#if !GLES
+			// Initialize draw buffer attachment array
+			int maxDrawBuffers;
+            GL.GetInteger(GetPName.MaxDrawBuffers, out maxDrawBuffers);
+            GraphicsExtensions.CheckGLError ();
+			_drawBuffers = new DrawBuffersEnum[maxDrawBuffers];
+			for (int i = 0; i < maxDrawBuffers; i++)
+				_drawBuffers[i] = (DrawBuffersEnum)(FramebufferAttachment.ColorAttachment0Ext + i);
+#endif
+        }
+
+        private void PlatformInitialize()
+        {
+            _viewport = new Viewport(0, 0, PresentationParameters.BackBufferWidth, PresentationParameters.BackBufferHeight);
+
+            // Ensure the vertex attributes are reset
+            _enabledVertexAttributes.Clear();
+
+            // Free all the cached shader programs. 
+            _programCache.Clear();
+            _shaderProgram = null;
+
+            framebufferHelper = FramebufferHelper.Create(this);
+
+            // Force resetting states
+            this.PlatformApplyBlend(true);
+            this.DepthStencilState.PlatformApplyState(this, true);
+            this.RasterizerState.PlatformApplyState(this, true);
+
+            _bufferBindingInfos = new BufferBindingInfo[_maxVertexBufferSlots];
+            for (int i = 0; i < _bufferBindingInfos.Length; i++)
+                _bufferBindingInfos[i] = new BufferBindingInfo(null, IntPtr.Zero, 0, -1);
+        }
+        
+        private DepthStencilState clearDepthStencilState = new DepthStencilState { StencilEnable = true };
+
+        public void PlatformClear(ClearOptions options, Vector4 color, float depth, int stencil)
+        {
+            // TODO: We need to figure out how to detect if we have a
+            // depth stencil buffer or not, and clear options relating
+            // to them if not attached.
+
+            // Unlike with XNA and DirectX...  GL.Clear() obeys several
+            // different render states:
+            //
+            //  - The color write flags.
+            //  - The scissor rectangle.
+            //  - The depth/stencil state.
+            //
+            // So overwrite these states with what is needed to perform
+            // the clear correctly and restore it afterwards.
+            //
+		    var prevScissorRect = ScissorRectangle;
+		    var prevDepthStencilState = DepthStencilState;
+            var prevBlendState = BlendState;
+            ScissorRectangle = _viewport.Bounds;
+            // DepthStencilState.Default has the Stencil Test disabled; 
+            // make sure stencil test is enabled before we clear since
+            // some drivers won't clear with stencil test disabled
+            DepthStencilState = this.clearDepthStencilState;
+		    BlendState = BlendState.Opaque;
+            ApplyState(false);
+
+            ClearBufferMask bufferMask = 0;
+            if ((options & ClearOptions.Target) == ClearOptions.Target)
+            {
+                if (color != _lastClearColor)
+                {
+                    GL.ClearColor(color.X, color.Y, color.Z, color.W);
+                    GraphicsExtensions.CheckGLError();
+                    _lastClearColor = color;
+                }
+                bufferMask = bufferMask | ClearBufferMask.ColorBufferBit;
+            }
+			if ((options & ClearOptions.Stencil) == ClearOptions.Stencil)
+            {
+                if (stencil != _lastClearStencil)
+                {
+				    GL.ClearStencil(stencil);
+                    GraphicsExtensions.CheckGLError();
+                    _lastClearStencil = stencil;
+                }
+                bufferMask = bufferMask | ClearBufferMask.StencilBufferBit;
+			}
+
+			if ((options & ClearOptions.DepthBuffer) == ClearOptions.DepthBuffer) 
+            {
+                if (depth != _lastClearDepth)
+                {
+                    GL.ClearDepth(depth);
+                    GraphicsExtensions.CheckGLError();
+                    _lastClearDepth = depth;
+                }
+				bufferMask = bufferMask | ClearBufferMask.DepthBufferBit;
+			}
+
+#if MONOMAC
+            if (GL.CheckFramebufferStatus(FramebufferTarget.FramebufferExt) == FramebufferErrorCode.FramebufferComplete)
+            {
+#endif
+                GL.Clear(bufferMask);
+                GraphicsExtensions.CheckGLError();
+#if MONOMAC
+            }
+#endif
+           		
+            // Restore the previous render state.
+		    ScissorRectangle = prevScissorRect;
+		    DepthStencilState = prevDepthStencilState;
+		    BlendState = prevBlendState;
+        }
+
+        private void PlatformDispose()
+        {
+            // Free all the cached shader programs.
+            _programCache.Dispose();
+
+#if DESKTOPGL || ANGLE
+            Context.Dispose();
+            Context = null;
+#endif
+        }
+
+        internal void DisposeTexture(int handle)
+        {
+            if (!_isDisposed)
+            {
+                lock (_disposeActionsLock)
+                {
+                    _disposeNextFrame.Add(ResourceHandle.Texture(handle));
+                }
+            }
+        }
+
+        internal void DisposeBuffer(int handle)
+        {
+            if (!_isDisposed)
+            {
+                lock (_disposeActionsLock)
+                {
+                    _disposeNextFrame.Add(ResourceHandle.Buffer(handle));
+                }
+            }
+        }
+
+        internal void DisposeShader(int handle)
+        {
+            if (!_isDisposed)
+            {
+                lock (_disposeActionsLock)
+                {
+                    _disposeNextFrame.Add(ResourceHandle.Shader(handle));
+                }
+            }
+        }
+
+        internal void DisposeProgram(int handle)
+        {
+            if (!_isDisposed)
+            {
+                lock (_disposeActionsLock)
+                {
+                    _disposeNextFrame.Add(ResourceHandle.Program(handle));
+                }
+            }
+        }
+
+        internal void DisposeQuery(int handle)
+        {
+            if (!_isDisposed)
+            {
+                lock (_disposeActionsLock)
+                {
+                    _disposeNextFrame.Add(ResourceHandle.Query(handle));
+                }
+            }
+        }
+
+        internal void DisposeFramebuffer(int handle)
+        {
+            if (!_isDisposed)
+            {
+                lock (_disposeActionsLock)
+                {
+                    _disposeNextFrame.Add(ResourceHandle.Framebuffer(handle));
+                }
+            }
+        }
+
+#if DESKTOPGL || ANGLE
+        static internal void DisposeContext(IntPtr resource)
+        {
+            lock (_disposeContextsLock)
+            {
+                _disposeContexts.Add(resource);
+            }
+        }
+
+        static internal void DisposeContexts()
+        {
+            lock (_disposeContextsLock)
+            {
+                int count = _disposeContexts.Count;
+                for (int i = 0; i < count; ++i)
+                    Sdl.GL.DeleteContext(_disposeContexts[i]);
+                _disposeContexts.Clear();
+            }
+        }
+#endif
+
+        public void PlatformPresent()
+        {
+#if DESKTOPGL || ANGLE
+            Context.SwapBuffers();
+#endif
+            GraphicsExtensions.CheckGLError();
+
+            // Dispose of any GL resources that were disposed in another thread
+            int count = _disposeThisFrame.Count;
+            for (int i = 0; i < count; ++i)
+                _disposeThisFrame[i].Free();
+            _disposeThisFrame.Clear();
+
+            lock (_disposeActionsLock)
+            {
+                // Swap lists so resources added during this draw will be released after the next draw
+                var temp = _disposeThisFrame;
+                _disposeThisFrame = _disposeNextFrame;
+                _disposeNextFrame = temp;
+            }
+        }
+
+        private void PlatformSetViewport(ref Viewport value)
+        {
+            if (IsRenderTargetBound)
+                GL.Viewport(value.X, value.Y, value.Width, value.Height);
+            else
+                GL.Viewport(value.X, PresentationParameters.BackBufferHeight - value.Y - value.Height, value.Width, value.Height);
+            GraphicsExtensions.LogGLError("GraphicsDevice.Viewport_set() GL.Viewport");
+
+            GL.DepthRange(value.MinDepth, value.MaxDepth);
+            GraphicsExtensions.LogGLError("GraphicsDevice.Viewport_set() GL.DepthRange");
+                
+            // In OpenGL we have to re-apply the special "posFixup"
+            // vertex shader uniform if the viewport changes.
+            _vertexShaderDirty = true;
+
+        }
+
+        private void PlatformApplyDefaultRenderTarget()
+        {
+            this.framebufferHelper.BindFramebuffer(this.glFramebuffer);
+
+            // Reset the raster state because we flip vertices
+            // when rendering offscreen and hence the cull direction.
+            _rasterizerStateDirty = true;
+
+            // Textures will need to be rebound to render correctly in the new render target.
+            Textures.Dirty();
+        }
+
+        private class RenderTargetBindingArrayComparer : IEqualityComparer<RenderTargetBinding[]>
+        {
+            public bool Equals(RenderTargetBinding[] first, RenderTargetBinding[] second)
+            {
+                if (object.ReferenceEquals(first, second))
+                    return true;
+
+                if (first == null || second == null)
+                    return false;
+
+                if (first.Length != second.Length)
+                    return false;
+
+                for (var i = 0; i < first.Length; ++i)
+                {
+                    if ((first[i].RenderTarget != second[i].RenderTarget) || (first[i].ArraySlice != second[i].ArraySlice))
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+
+            public int GetHashCode(RenderTargetBinding[] array)
+            {
+                if (array != null)
+                {
+                    unchecked
+                    {
+                        int hash = 17;
+                        foreach (var item in array)
+                        {
+                            if (item.RenderTarget != null)
+                                hash = hash * 23 + item.RenderTarget.GetHashCode();
+                            hash = hash * 23 + item.ArraySlice.GetHashCode();
+                        }
+                        return hash;
+                    }
+                }
+                return 0;
+            }
+        }
+
+        // FBO cache, we create 1 FBO per RenderTargetBinding combination
+        private Dictionary<RenderTargetBinding[], int> glFramebuffers = new Dictionary<RenderTargetBinding[], int>(new RenderTargetBindingArrayComparer());
+        // FBO cache used to resolve MSAA rendertargets, we create 1 FBO per RenderTargetBinding combination
+        private Dictionary<RenderTargetBinding[], int> glResolveFramebuffers = new Dictionary<RenderTargetBinding[], int>(new RenderTargetBindingArrayComparer());
+
+        internal void PlatformCreateRenderTarget(IRenderTarget renderTarget, int width, int height, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
+        {
+            var color = 0;
+            var depth = 0;
+            var stencil = 0;
+            
+            if (preferredMultiSampleCount > 0 && this.framebufferHelper.SupportsBlitFramebuffer)
+            {
+                this.framebufferHelper.GenRenderbuffer(out color);
+                this.framebufferHelper.BindRenderbuffer(color);
+                this.framebufferHelper.RenderbufferStorageMultisample(preferredMultiSampleCount, (int)RenderbufferStorage.Rgba8, width, height);
+            }
+
+            if (preferredDepthFormat != DepthFormat.None)
+            {
+                var depthInternalFormat = RenderbufferStorage.DepthComponent16;
+                var stencilInternalFormat = (RenderbufferStorage)0;
+                switch (preferredDepthFormat)
+                {
+                    case DepthFormat.Depth16: 
+                        depthInternalFormat = RenderbufferStorage.DepthComponent16;
+                        break;
+#if GLES
+                    case DepthFormat.Depth24:
+                        if (GraphicsCapabilities.SupportsDepth24)
+                            depthInternalFormat = RenderbufferStorage.DepthComponent24Oes;
+                        else if (GraphicsCapabilities.SupportsDepthNonLinear)
+                            depthInternalFormat = (RenderbufferStorage)0x8E2C;
+                        else
+                            depthInternalFormat = RenderbufferStorage.DepthComponent16;
+                        break;
+                    case DepthFormat.Depth24Stencil8:
+                        if (GraphicsCapabilities.SupportsPackedDepthStencil)
+                            depthInternalFormat = RenderbufferStorage.Depth24Stencil8Oes;
+                        else
+                        {
+                            if (GraphicsCapabilities.SupportsDepth24)
+                                depthInternalFormat = RenderbufferStorage.DepthComponent24Oes;
+                            else if (GraphicsCapabilities.SupportsDepthNonLinear)
+                                depthInternalFormat = (RenderbufferStorage)0x8E2C;
+                            else
+                                depthInternalFormat = RenderbufferStorage.DepthComponent16;
+                            stencilInternalFormat = RenderbufferStorage.StencilIndex8;
+                            break;
+                        }
+                        break;
+#else
+                    case DepthFormat.Depth24:
+                        depthInternalFormat = RenderbufferStorage.DepthComponent24;
+                        break;
+                    case DepthFormat.Depth24Stencil8:
+                        depthInternalFormat = RenderbufferStorage.Depth24Stencil8;
+                        break;
+#endif
+                }
+
+                if (depthInternalFormat != 0)
+                {
+                    this.framebufferHelper.GenRenderbuffer(out depth);
+                    this.framebufferHelper.BindRenderbuffer(depth);
+                    this.framebufferHelper.RenderbufferStorageMultisample(preferredMultiSampleCount, (int)depthInternalFormat, width, height);
+                    if (preferredDepthFormat == DepthFormat.Depth24Stencil8)
+                    {
+                        stencil = depth;
+                        if (stencilInternalFormat != 0)
+                        {
+                            this.framebufferHelper.GenRenderbuffer(out stencil);
+                            this.framebufferHelper.BindRenderbuffer(stencil);
+                            this.framebufferHelper.RenderbufferStorageMultisample(preferredMultiSampleCount, (int)stencilInternalFormat, width, height);
+                        }
+                    }
+                }
+            }
+
+            if (color != 0)
+                renderTarget.GLColorBuffer = color;
+            else
+                renderTarget.GLColorBuffer = renderTarget.GLTexture;
+            renderTarget.GLDepthBuffer = depth;
+            renderTarget.GLStencilBuffer = stencil;
+        }
+
+        internal void PlatformDeleteRenderTarget(IRenderTarget renderTarget)
+        {
+            var color = 0;
+            var depth = 0;
+            var stencil = 0;
+            var colorIsRenderbuffer = false;
+
+            color = renderTarget.GLColorBuffer;
+            depth = renderTarget.GLDepthBuffer;
+            stencil = renderTarget.GLStencilBuffer;
+            colorIsRenderbuffer = color != renderTarget.GLTexture;
+
+            if (color != 0)
+            {
+                if (colorIsRenderbuffer)
+                    this.framebufferHelper.DeleteRenderbuffer(color);
+                if (stencil != 0 && stencil != depth)
+                    this.framebufferHelper.DeleteRenderbuffer(stencil);
+                if (depth != 0)
+                    this.framebufferHelper.DeleteRenderbuffer(depth);
+
+                var bindingsToDelete = new List<RenderTargetBinding[]>();
+                foreach (var bindings in this.glFramebuffers.Keys)
+                {
+                    foreach (var binding in bindings)
+                    {
+                        if (binding.RenderTarget == renderTarget)
+                        {
+                            bindingsToDelete.Add(bindings);
+                            break;
+                        }
+                    }
+                }
+
+                foreach (var bindings in bindingsToDelete)
+                {
+                    var fbo = 0;
+                    if (this.glFramebuffers.TryGetValue(bindings, out fbo))
+                    {
+                        this.framebufferHelper.DeleteFramebuffer(fbo);
+                        this.glFramebuffers.Remove(bindings);
+                    }
+                    if (this.glResolveFramebuffers.TryGetValue(bindings, out fbo))
+                    {
+                        this.framebufferHelper.DeleteFramebuffer(fbo);
+                        this.glResolveFramebuffers.Remove(bindings);
+                    }
+                }
+            }
+        }
+
+        private void PlatformResolveRenderTargets()
+        {
+            if (this._currentRenderTargetCount == 0)
+                return;
+
+            var renderTargetBinding = this._currentRenderTargetBindings[0];
+            var renderTarget = renderTargetBinding.RenderTarget as IRenderTarget;
+            if (renderTarget.MultiSampleCount > 0 && this.framebufferHelper.SupportsBlitFramebuffer)
+            {
+                var glResolveFramebuffer = 0;
+                if (!this.glResolveFramebuffers.TryGetValue(this._currentRenderTargetBindings, out glResolveFramebuffer))
+                {
+                    this.framebufferHelper.GenFramebuffer(out glResolveFramebuffer);
+                    this.framebufferHelper.BindFramebuffer(glResolveFramebuffer);
+                    for (var i = 0; i < this._currentRenderTargetCount; ++i)
+                    {
+                        var rt = this._currentRenderTargetBindings[i].RenderTarget as IRenderTarget;
+                        this.framebufferHelper.FramebufferTexture2D((int)(FramebufferAttachment.ColorAttachment0 + i), (int) rt.GetFramebufferTarget(renderTargetBinding), rt.GLTexture);
+                    }
+                    this.glResolveFramebuffers.Add((RenderTargetBinding[])this._currentRenderTargetBindings.Clone(), glResolveFramebuffer);
+                }
+                else
+                {
+                    this.framebufferHelper.BindFramebuffer(glResolveFramebuffer);
+                }
+                // The only fragment operations which affect the resolve are the pixel ownership test, the scissor test, and dithering.
+                if (this._lastRasterizerState.ScissorTestEnable)
+                {
+                    GL.Disable(EnableCap.ScissorTest);
+                    GraphicsExtensions.CheckGLError();
+                }
+                var glFramebuffer = this.glFramebuffers[this._currentRenderTargetBindings];
+                this.framebufferHelper.BindReadFramebuffer(glFramebuffer);
+                for (var i = 0; i < this._currentRenderTargetCount; ++i)
+                {
+                    renderTargetBinding = this._currentRenderTargetBindings[i];
+                    renderTarget = renderTargetBinding.RenderTarget as IRenderTarget;
+                    this.framebufferHelper.BlitFramebuffer(i, renderTarget.Width, renderTarget.Height);
+                }
+                if (renderTarget.RenderTargetUsage == RenderTargetUsage.DiscardContents && this.framebufferHelper.SupportsInvalidateFramebuffer)
+                    this.framebufferHelper.InvalidateReadFramebuffer();
+                if (this._lastRasterizerState.ScissorTestEnable)
+                {
+                    GL.Enable(EnableCap.ScissorTest);
+                    GraphicsExtensions.CheckGLError();
+                }
+            }
+            for (var i = 0; i < this._currentRenderTargetCount; ++i)
+            {
+                renderTargetBinding = this._currentRenderTargetBindings[i];
+                renderTarget = renderTargetBinding.RenderTarget as IRenderTarget;
+                if (renderTarget.LevelCount > 1)
+                {
+                    GL.BindTexture((TextureTarget)renderTarget.GLTarget, renderTarget.GLTexture);
+                    GraphicsExtensions.CheckGLError();
+                    this.framebufferHelper.GenerateMipmap((int)renderTarget.GLTarget);
+                }
+            }
+        }
+
+        private IRenderTarget PlatformApplyRenderTargets()
+        {
+            var glFramebuffer = 0;
+            if (!this.glFramebuffers.TryGetValue(this._currentRenderTargetBindings, out glFramebuffer))
+            {
+                this.framebufferHelper.GenFramebuffer(out glFramebuffer);
+                this.framebufferHelper.BindFramebuffer(glFramebuffer);
+                var renderTargetBinding = this._currentRenderTargetBindings[0];
+                var renderTarget = renderTargetBinding.RenderTarget as IRenderTarget;
+                this.framebufferHelper.FramebufferRenderbuffer((int)FramebufferAttachment.DepthAttachment, renderTarget.GLDepthBuffer, 0);
+                this.framebufferHelper.FramebufferRenderbuffer((int)FramebufferAttachment.StencilAttachment, renderTarget.GLStencilBuffer, 0);
+                for (var i = 0; i < this._currentRenderTargetCount; ++i)
+                {
+                    renderTargetBinding = this._currentRenderTargetBindings[i];
+                    renderTarget = renderTargetBinding.RenderTarget as IRenderTarget;
+                    var attachement = (int)(FramebufferAttachment.ColorAttachment0 + i);
+                    if (renderTarget.GLColorBuffer != renderTarget.GLTexture)
+                        this.framebufferHelper.FramebufferRenderbuffer(attachement, renderTarget.GLColorBuffer, 0);
+                    else
+                        this.framebufferHelper.FramebufferTexture2D(attachement, (int)renderTarget.GetFramebufferTarget(renderTargetBinding), renderTarget.GLTexture, 0, renderTarget.MultiSampleCount);
+                }
+
+#if DEBUG
+                this.framebufferHelper.CheckFramebufferStatus();
+#endif
+                this.glFramebuffers.Add((RenderTargetBinding[])_currentRenderTargetBindings.Clone(), glFramebuffer);
+            }
+            else
+            {
+                this.framebufferHelper.BindFramebuffer(glFramebuffer);
+            }
+#if !GLES
+            GL.DrawBuffers(this._currentRenderTargetCount, this._drawBuffers);
+#endif
+
+            // Reset the raster state because we flip vertices
+            // when rendering offscreen and hence the cull direction.
+            _rasterizerStateDirty = true;
+
+            // Textures will need to be rebound to render correctly in the new render target.
+            Textures.Dirty();
+
+            return _currentRenderTargetBindings[0].RenderTarget as IRenderTarget;
+        }
+
+        private static GLPrimitiveType PrimitiveTypeGL(PrimitiveType primitiveType)
+        {
+            switch (primitiveType)
+            {
+                case PrimitiveType.LineList:
+                    return GLPrimitiveType.Lines;
+                case PrimitiveType.LineStrip:
+                    return GLPrimitiveType.LineStrip;
+                case PrimitiveType.TriangleList:
+                    return GLPrimitiveType.Triangles;
+                case PrimitiveType.TriangleStrip:
+                    return GLPrimitiveType.TriangleStrip;
+            }
+
+            throw new ArgumentException();
+        }
+
+        /// <summary>
+        /// Activates the Current Vertex/Pixel shader pair into a program.         
+        /// </summary>
+        private unsafe void ActivateShaderProgram()
+        {
+            // Lookup the shader program.
+            var shaderProgram = _programCache.GetProgram(VertexShader, PixelShader);
+            if (shaderProgram.Program == -1)
+                return;
+            // Set the new program if it has changed.
+            if (_shaderProgram != shaderProgram)
+            {
+                GL.UseProgram(shaderProgram.Program);
+                GraphicsExtensions.CheckGLError();
+                _shaderProgram = shaderProgram;
+            }
+
+            var posFixupLoc = shaderProgram.GetUniformLocation("posFixup");
+            if (posFixupLoc == -1)
+                return;
+
+            // Apply vertex shader fix:
+            // The following two lines are appended to the end of vertex shaders
+            // to account for rendering differences between OpenGL and DirectX:
+            //
+            // gl_Position.y = gl_Position.y * posFixup.y;
+            // gl_Position.xy += posFixup.zw * gl_Position.ww;
+            //
+            // (the following paraphrased from wine, wined3d/state.c and wined3d/glsl_shader.c)
+            //
+            // - We need to flip along the y-axis in case of offscreen rendering.
+            // - D3D coordinates refer to pixel centers while GL coordinates refer
+            //   to pixel corners.
+            // - D3D has a top-left filling convention. We need to maintain this
+            //   even after the y-flip mentioned above.
+            // In order to handle the last two points, we translate by
+            // (63.0 / 128.0) / VPw and (63.0 / 128.0) / VPh. This is equivalent to
+            // translating slightly less than half a pixel. We want the difference to
+            // be large enough that it doesn't get lost due to rounding inside the
+            // driver, but small enough to prevent it from interfering with any
+            // anti-aliasing.
+            //
+            // OpenGL coordinates specify the center of the pixel while d3d coords specify
+            // the corner. The offsets are stored in z and w in posFixup. posFixup.y contains
+            // 1.0 or -1.0 to turn the rendering upside down for offscreen rendering. PosFixup.x
+            // contains 1.0 to allow a mad.
+
+            _posFixup[0] = 1.0f;
+            _posFixup[1] = 1.0f;
+            _posFixup[2] = (63.0f/64.0f)/Viewport.Width;
+            _posFixup[3] = -(63.0f/64.0f)/Viewport.Height;
+
+            //If we have a render target bound (rendering offscreen)
+            if (IsRenderTargetBound)
+            {
+                //flip vertically
+                _posFixup[1] *= -1.0f;
+                _posFixup[3] *= -1.0f;
+            }
+
+            fixed (float* floatPtr = _posFixup)
+            {
+                GL.Uniform4(posFixupLoc, 1, floatPtr);
+            }
+            GraphicsExtensions.CheckGLError();
+        }
+
+        internal void PlatformBeginApplyState()
+        {
+            Threading.EnsureUIThread();
+        }
+
+        private void PlatformApplyBlend(bool force = false)
+        {
+            _actualBlendState.PlatformApplyState(this, force);
+            ApplyBlendFactor(force);
+        }
+
+        private void ApplyBlendFactor(bool force)
+        {
+            if (force || BlendFactor != _lastBlendState.BlendFactor)
+            {
+                GL.BlendColor(
+                    this.BlendFactor.R/255.0f,
+                    this.BlendFactor.G/255.0f,
+                    this.BlendFactor.B/255.0f,
+                    this.BlendFactor.A/255.0f);
+                GraphicsExtensions.CheckGLError();
+                _lastBlendState.BlendFactor = this.BlendFactor;
+            }
+        }
+
+        internal void PlatformApplyState(bool applyShaders)
+        {
+            if ( _scissorRectangleDirty )
+	        {
+                var scissorRect = _scissorRectangle;
+                if (!IsRenderTargetBound)
+                    scissorRect.Y = PresentationParameters.BackBufferHeight - (scissorRect.Y + scissorRect.Height);
+                GL.Scissor(scissorRect.X, scissorRect.Y, scissorRect.Width, scissorRect.Height);
+                GraphicsExtensions.CheckGLError();
+	            _scissorRectangleDirty = false;
+	        }
+
+            // If we're not applying shaders then early out now.
+            if (!applyShaders)
+                return;
+
+            if (_indexBufferDirty)
+            {
+                if (_indexBuffer != null)
+                {
+                    GL.BindBuffer(BufferTarget.ElementArrayBuffer, _indexBuffer.ibo);
+                    GraphicsExtensions.CheckGLError();
+                }
+                _indexBufferDirty = false;
+            }
+
+            if (_vertexShader == null)
+                throw new InvalidOperationException("A vertex shader must be set!");
+            if (_pixelShader == null)
+                throw new InvalidOperationException("A pixel shader must be set!");
+
+            if (_vertexShaderDirty || _pixelShaderDirty)
+            {
+                ActivateShaderProgram();
+
+                if (_vertexShaderDirty)
+                {
+                    unchecked
+                    {
+                        _graphicsMetrics._vertexShaderCount++;
+                    }
+                }
+
+                if (_pixelShaderDirty)
+                {
+                    unchecked
+                    {
+                        _graphicsMetrics._pixelShaderCount++;
+                    }
+                }
+
+                _vertexShaderDirty = _pixelShaderDirty = false;
+            }
+
+            _vertexConstantBuffers.SetConstantBuffers(this, _shaderProgram);
+            _pixelConstantBuffers.SetConstantBuffers(this, _shaderProgram);
+
+            Textures.SetTextures(this);
+            SamplerStates.PlatformSetSamplers(this);
+        }
+
+        private void PlatformDrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int startIndex, int primitiveCount)
+        {
+            ApplyState(true);
+
+            var shortIndices = _indexBuffer.IndexElementSize == IndexElementSize.SixteenBits;
+
+			var indexElementType = shortIndices ? DrawElementsType.UnsignedShort : DrawElementsType.UnsignedInt;
+            var indexElementSize = shortIndices ? 2 : 4;
+			var indexOffsetInBytes = (IntPtr)(startIndex * indexElementSize);
+			var indexElementCount = GetElementCountArray(primitiveType, primitiveCount);
+			var target = PrimitiveTypeGL(primitiveType);
+
+            ApplyAttribs(_vertexShader, baseVertex);
+
+            GL.DrawElements(target,
+                                     indexElementCount,
+                                     indexElementType,
+                                     indexOffsetInBytes);
+            GraphicsExtensions.CheckGLError();
+        }
+
+        private void PlatformDrawUserPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, VertexDeclaration vertexDeclaration, int vertexCount) where T : struct
+        {
+            ApplyState(true);
+
+            // Unbind current VBOs.
+            GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
+            GraphicsExtensions.CheckGLError();
+            GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
+            GraphicsExtensions.CheckGLError();
+            _indexBufferDirty = true;
+
+            // Pin the buffers.
+            var vbHandle = GCHandle.Alloc(vertexData, GCHandleType.Pinned);
+
+            // Setup the vertex declaration to point at the VB data.
+            vertexDeclaration.GraphicsDevice = this;
+            vertexDeclaration.Apply(_vertexShader, vbHandle.AddrOfPinnedObject(), ShaderProgramHash);
+
+            //Draw
+            GL.DrawArrays(PrimitiveTypeGL(primitiveType),
+                          vertexOffset,
+                          vertexCount);
+            GraphicsExtensions.CheckGLError();
+
+            // Release the handles.
+            vbHandle.Free();
+        }
+
+        private void PlatformDrawPrimitives(PrimitiveType primitiveType, int vertexStart, int vertexCount)
+        {
+            ApplyState(true);   
+
+            ApplyAttribs(_vertexShader, 0);
+
+            if (vertexStart < 0)
+                vertexStart = 0;
+
+			GL.DrawArrays(PrimitiveTypeGL(primitiveType),
+			              vertexStart,
+			              vertexCount);
+            GraphicsExtensions.CheckGLError();
+        }
+
+        private void PlatformDrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices, short[] indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration) where T : struct
+        {
+            ApplyState(true);
+
+            // Unbind current VBOs.
+            GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
+            GraphicsExtensions.CheckGLError();
+            GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
+            GraphicsExtensions.CheckGLError();
+            _indexBufferDirty = true;
+
+            // Pin the buffers.
+            var vbHandle = GCHandle.Alloc(vertexData, GCHandleType.Pinned);
+            var ibHandle = GCHandle.Alloc(indexData, GCHandleType.Pinned);
+
+            var vertexAddr = (IntPtr)(vbHandle.AddrOfPinnedObject().ToInt64() + vertexDeclaration.VertexStride * vertexOffset);
+
+            // Setup the vertex declaration to point at the VB data.
+            vertexDeclaration.GraphicsDevice = this;
+            vertexDeclaration.Apply(_vertexShader, vertexAddr, ShaderProgramHash);
+
+            //Draw
+            GL.DrawElements(    PrimitiveTypeGL(primitiveType),
+                                GetElementCountArray(primitiveType, primitiveCount),
+                                DrawElementsType.UnsignedShort,
+                                (IntPtr)(ibHandle.AddrOfPinnedObject().ToInt64() + (indexOffset * sizeof(short))));
+            GraphicsExtensions.CheckGLError();
+
+            // Release the handles.
+            ibHandle.Free();
+            vbHandle.Free();
+        }
+
+        private void PlatformDrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices, int[] indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration) where T : struct
+        {
+            ApplyState(true);
+
+            // Unbind current VBOs.
+            GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
+            GraphicsExtensions.CheckGLError();
+            GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
+            GraphicsExtensions.CheckGLError();
+            _indexBufferDirty = true;
+
+            // Pin the buffers.
+            var vbHandle = GCHandle.Alloc(vertexData, GCHandleType.Pinned);
+            var ibHandle = GCHandle.Alloc(indexData, GCHandleType.Pinned);
+
+            var vertexAddr = (IntPtr)(vbHandle.AddrOfPinnedObject().ToInt64() + vertexDeclaration.VertexStride * vertexOffset);
+
+            // Setup the vertex declaration to point at the VB data.
+            vertexDeclaration.GraphicsDevice = this;
+            vertexDeclaration.Apply(_vertexShader, vertexAddr, ShaderProgramHash);
+
+            //Draw
+            GL.DrawElements(    PrimitiveTypeGL(primitiveType),
+                                GetElementCountArray(primitiveType, primitiveCount),
+                                DrawElementsType.UnsignedInt,
+                                (IntPtr)(ibHandle.AddrOfPinnedObject().ToInt64() + (indexOffset * sizeof(int))));
+            GraphicsExtensions.CheckGLError();
+
+            // Release the handles.
+            ibHandle.Free();
+            vbHandle.Free();
+        }
+
+        private void PlatformDrawInstancedPrimitives(PrimitiveType primitiveType, int baseVertex, int startIndex, int primitiveCount, int instanceCount)
+        {
+            if (!GraphicsCapabilities.SupportsInstancing)
+                throw new PlatformNotSupportedException("Instanced geometry drawing requires at least OpenGL 3.2 or GLES 3.2. Try upgrading your graphics card drivers.");
+            ApplyState(true);
+
+            var shortIndices = _indexBuffer.IndexElementSize == IndexElementSize.SixteenBits;
+
+            var indexElementType = shortIndices ? DrawElementsType.UnsignedShort : DrawElementsType.UnsignedInt;
+            var indexElementSize = shortIndices ? 2 : 4;
+            var indexOffsetInBytes = (IntPtr)(startIndex * indexElementSize);
+            var indexElementCount = GetElementCountArray(primitiveType, primitiveCount);
+            var target = PrimitiveTypeGL(primitiveType);
+
+            ApplyAttribs(_vertexShader, baseVertex);
+
+            GL.DrawElementsInstanced(target,
+                                     indexElementCount,
+                                     indexElementType,
+                                     indexOffsetInBytes,
+                                     instanceCount);
+            GraphicsExtensions.CheckGLError();
+        }
+
+        private void PlatformGetBackBufferData<T>(Rectangle? rectangle, T[] data, int startIndex, int count) where T : struct
+        {
+            var rect = rectangle ?? new Rectangle(0, 0, PresentationParameters.BackBufferWidth, PresentationParameters.BackBufferHeight);
+            var tSize = Marshal.SizeOf(typeof(T));
+            var flippedY = PresentationParameters.BackBufferHeight - rect.Y - rect.Height;
+            GL.ReadPixels(rect.X, flippedY, rect.Width, rect.Height, PixelFormat.Rgba, PixelType.UnsignedByte, data);
+
+            // buffer is returned upside down, so we swap the rows around when copying over
+            var rowSize = rect.Width*PresentationParameters.BackBufferFormat.GetSize() / tSize;
+            var row = new T[rowSize];
+            for (var dy = 0; dy < rect.Height/2; dy++)
+            {
+                var topRow = startIndex + dy*rowSize;
+                var bottomRow = startIndex + (rect.Height - dy - 1)*rowSize;
+                // copy the bottom row to buffer
+                Array.Copy(data, bottomRow, row, 0, rowSize);
+                // copy top row to bottom row
+                Array.Copy(data, topRow, data, bottomRow, rowSize);
+                // copy buffer to top row
+                Array.Copy(row, 0, data, topRow, rowSize);
+                count -= rowSize;
+            }
+        }
+
+        private static Rectangle PlatformGetTitleSafeArea(int x, int y, int width, int height)
+        {
+            return new Rectangle(x, y, width, height);
+        }
+        
+        internal void PlatformSetMultiSamplingToMaximum(PresentationParameters presentationParameters, out int quality)
+        {
+            presentationParameters.MultiSampleCount = 4;
+            quality = 0;
+        }
+
+        internal void OnPresentationChanged()
+        {
+#if DESKTOPGL || ANGLE
+            Context.MakeCurrent(new WindowInfo(SdlGameWindow.Instance.Handle));
+            Context.SwapInterval = PresentationParameters.PresentationInterval.GetSwapInterval();
+#endif
+
+            ApplyRenderTargets(null);
+        }
+
+        // Holds information for caching
+        private class BufferBindingInfo
+        {
+            public VertexDeclaration.VertexDeclarationAttributeInfo AttributeInfo;
+            public IntPtr VertexOffset;
+            public int InstanceFrequency;
+            public int Vbo;
+
+            public BufferBindingInfo(VertexDeclaration.VertexDeclarationAttributeInfo attributeInfo, IntPtr vertexOffset, int instanceFrequency, int vbo)
+            {
+                AttributeInfo = attributeInfo;
+                VertexOffset = vertexOffset;
+                InstanceFrequency = instanceFrequency;
+                Vbo = vbo;
+            }
+        }
+
+#if DESKTOPGL
+        private void GetModeSwitchedSize(out int width, out int height)
+        {
+            var mode = new Sdl.Display.Mode
+            {
+                Width = PresentationParameters.BackBufferWidth,
+                Height = PresentationParameters.BackBufferHeight,
+                Format = 0,
+                RefreshRate = 0,
+                DriverData = IntPtr.Zero
+            };
+            Sdl.Display.Mode closest;
+            Sdl.Display.GetClosestDisplayMode(0, mode, out closest);
+            width = closest.Width;
+            height = closest.Height;
+        }
+
+        private void GetDisplayResolution(out int width, out int height)
+        {
+            Sdl.Display.Mode mode;
+            Sdl.Display.GetCurrentDisplayMode(0, out mode);
+            width = mode.Width;
+            height = mode.Height;
+        }
+#endif
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsDevice.Web.cs b/MonoGame.Framework/Graphics/GraphicsDevice.Web.cs
new file mode 100644
index 00000000000..263f42bc243
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsDevice.Web.cs
@@ -0,0 +1,118 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Content;
+using Microsoft.Xna.Framework.Input.Touch;
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    using MonoGame.Web;
+
+    public partial class GraphicsDevice
+    {
+        private void PlatformSetup()
+        {
+            
+        }
+
+        private void PlatformInitialize()
+        {
+        }
+
+        internal void OnPresentationChanged()
+        {
+        }
+
+        public void PlatformClear(ClearOptions options, Vector4 color, float depth, int stencil)
+        {
+            WebGL.gl.enable(WebGL.gl.DEPTH_TEST);
+            WebGL.gl.depthFunc(WebGL.gl.LEQUAL);
+            WebGL.gl.clearColor(color.X, color.Y, color.Z, color.W);
+            WebGL.gl.clear(WebGL.gl.COLOR_BUFFER_BIT | WebGL.gl.DEPTH_BUFFER_BIT);
+        }
+
+        private void PlatformDispose()
+        {
+        }
+
+        public void PlatformPresent()
+        {
+        }
+
+        private void PlatformSetViewport(ref Viewport value)
+        {
+        }
+
+        private void PlatformApplyDefaultRenderTarget()
+        {
+        }
+
+        internal void PlatformResolveRenderTargets()
+        {
+            // Resolving MSAA render targets should be done here.
+        }
+
+        private IRenderTarget PlatformApplyRenderTargets()
+        {
+            return null;
+        }
+		
+        internal void PlatformBeginApplyState()
+        {
+        }
+
+        private void PlatformApplyBlend()
+        {
+        }
+
+        internal void PlatformApplyState(bool applyShaders)
+        {
+        }
+
+        private void PlatformDrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int startIndex, int primitiveCount)
+        {
+        }
+
+        private void PlatformDrawUserPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, VertexDeclaration vertexDeclaration, int vertexCount) where T : struct
+        {
+        }
+
+        private void PlatformDrawPrimitives(PrimitiveType primitiveType, int vertexStart, int vertexCount)
+        {
+        }
+
+        private void PlatformDrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices, short[] indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration) where T : struct
+        {
+        }
+
+        private void PlatformDrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices, int[] indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration) where T : struct
+        {
+        }
+
+        private void PlatformDrawInstancedPrimitives(PrimitiveType primitiveType, int baseVertex, int startIndex, int primitiveCount, int instanceCount)
+        {
+        }
+
+        private void PlatformGetBackBufferData<T>(Rectangle? rect, T[] data, int startIndex, int count) where T : struct
+        {
+            throw new NotImplementedException();
+        }
+
+        private static Rectangle PlatformGetTitleSafeArea(int x, int y, int width, int height)
+        {
+            return new Rectangle(x, y, width, height);
+        }
+        
+        internal void PlatformSetMultiSamplingToMaximum(PresentationParameters presentationParameters, out int quality)
+        {
+            presentationParameters.MultiSampleCount = 0;
+            quality = 0;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsDevice.cs b/MonoGame.Framework/Graphics/GraphicsDevice.cs
new file mode 100644
index 00000000000..77670da4771
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsDevice.cs
@@ -0,0 +1,1392 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using MonoGame.Utilities;
+using System.Runtime.InteropServices;
+
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class GraphicsDevice : IDisposable
+    {
+        private Viewport _viewport;
+
+        private bool _isDisposed;
+
+        private Color _blendFactor = Color.White;
+        private bool _blendFactorDirty;
+
+        private BlendState _blendState;
+        private BlendState _actualBlendState;
+        private bool _blendStateDirty;
+
+        private BlendState _blendStateAdditive;
+        private BlendState _blendStateAlphaBlend;
+        private BlendState _blendStateNonPremultiplied;
+        private BlendState _blendStateOpaque;
+
+        private DepthStencilState _depthStencilState;
+        private DepthStencilState _actualDepthStencilState;
+        private bool _depthStencilStateDirty;
+
+        private DepthStencilState _depthStencilStateDefault;
+        private DepthStencilState _depthStencilStateDepthRead;
+        private DepthStencilState _depthStencilStateNone;
+
+        private RasterizerState _rasterizerState;
+        private RasterizerState _actualRasterizerState;
+        private bool _rasterizerStateDirty;
+
+        private RasterizerState _rasterizerStateCullClockwise;
+        private RasterizerState _rasterizerStateCullCounterClockwise;
+        private RasterizerState _rasterizerStateCullNone;
+
+        private Rectangle _scissorRectangle;
+        private bool _scissorRectangleDirty;
+
+        private VertexBufferBindings _vertexBuffers;
+        private bool _vertexBuffersDirty;
+
+        private IndexBuffer _indexBuffer;
+        private bool _indexBufferDirty;
+
+        private readonly RenderTargetBinding[] _currentRenderTargetBindings = new RenderTargetBinding[4];
+        private int _currentRenderTargetCount;
+        private readonly RenderTargetBinding[] _tempRenderTargetBinding = new RenderTargetBinding[1];
+
+        internal GraphicsCapabilities GraphicsCapabilities { get; private set; }
+
+        public TextureCollection VertexTextures { get; private set; }
+
+        public SamplerStateCollection VertexSamplerStates { get; private set; }
+
+        public TextureCollection Textures { get; private set; }
+
+        public SamplerStateCollection SamplerStates { get; private set; }
+
+        // On Intel Integrated graphics, there is a fast hw unit for doing
+        // clears to colors where all components are either 0 or 255.
+        // Despite XNA4 using Purple here, we use black (in Release) to avoid
+        // performance warnings on Intel/Mesa
+#if DEBUG
+        private static readonly Color DiscardColor = new Color(68, 34, 136, 255);
+#else
+        private static readonly Color DiscardColor = new Color(0, 0, 0, 255);
+#endif
+
+        /// <summary>
+        /// The active vertex shader.
+        /// </summary>
+        private Shader _vertexShader;
+        private bool _vertexShaderDirty;
+        private bool VertexShaderDirty
+        {
+            get { return _vertexShaderDirty; }
+        }
+
+        /// <summary>
+        /// The active pixel shader.
+        /// </summary>
+        private Shader _pixelShader;
+        private bool _pixelShaderDirty;
+        private bool PixelShaderDirty
+        {
+            get { return _pixelShaderDirty; }
+        }
+
+        private readonly ConstantBufferCollection _vertexConstantBuffers = new ConstantBufferCollection(ShaderStage.Vertex, 16);
+        private readonly ConstantBufferCollection _pixelConstantBuffers = new ConstantBufferCollection(ShaderStage.Pixel, 16);
+
+        /// <summary>
+        /// The cache of effects from unique byte streams.
+        /// </summary>
+        internal Dictionary<int, Effect> EffectCache;
+
+        // Resources may be added to and removed from the list from many threads.
+        private readonly object _resourcesLock = new object();
+
+        // Use WeakReference for the global resources list as we do not know when a resource
+        // may be disposed and collected. We do not want to prevent a resource from being
+        // collected by holding a strong reference to it in this list.
+        private readonly List<WeakReference> _resources = new List<WeakReference>();
+
+		// TODO Graphics Device events need implementing
+		public event EventHandler<EventArgs> DeviceLost;
+		public event EventHandler<EventArgs> DeviceReset;
+		public event EventHandler<EventArgs> DeviceResetting;
+		public event EventHandler<ResourceCreatedEventArgs> ResourceCreated;
+		public event EventHandler<ResourceDestroyedEventArgs> ResourceDestroyed;
+        public event EventHandler<EventArgs> Disposing;
+
+        internal event EventHandler<PresentationEventArgs> PresentationChanged;
+
+        private int _maxVertexBufferSlots;
+        internal int MaxTextureSlots;
+        internal int MaxVertexTextureSlots;
+
+        public bool IsDisposed
+        {
+            get
+            {
+                return _isDisposed;
+            }
+        }
+
+		public bool IsContentLost {
+			get {
+				// We will just return IsDisposed for now
+				// as that is the only case I can see for now
+				return IsDisposed;
+			}
+		}
+
+        internal bool IsRenderTargetBound
+        {
+            get
+            {
+                return _currentRenderTargetCount > 0;
+            }
+        }
+
+        internal DepthFormat ActiveDepthFormat
+        {
+            get
+            {
+                return IsRenderTargetBound
+                    ? _currentRenderTargetBindings[0].DepthFormat
+                    : PresentationParameters.DepthStencilFormat;
+            }
+        }
+
+        public GraphicsAdapter Adapter
+        {
+            get;
+            private set;
+        }
+
+        internal GraphicsMetrics _graphicsMetrics;
+
+        /// <summary>
+        /// The rendering information for debugging and profiling.
+        /// The metrics are reset every frame after draw within <see cref="GraphicsDevice.Present"/>. 
+        /// </summary>
+        public GraphicsMetrics Metrics { get { return _graphicsMetrics; } set { _graphicsMetrics = value; } }
+
+        private GraphicsDebug _graphicsDebug;
+
+        /// <summary>
+        /// Access debugging APIs for the graphics subsystem.
+        /// </summary>
+        public GraphicsDebug GraphicsDebug { get { return _graphicsDebug; } set { _graphicsDebug = value; } }
+
+        internal GraphicsDevice(GraphicsDeviceInformation gdi)
+            : this(gdi.Adapter, gdi.GraphicsProfile, gdi.PresentationParameters)
+        {
+        }
+
+        internal GraphicsDevice()
+		{
+            PresentationParameters = new PresentationParameters();
+            PresentationParameters.DepthStencilFormat = DepthFormat.Depth24;
+            Setup();
+            GraphicsCapabilities = new GraphicsCapabilities();
+            GraphicsCapabilities.Initialize(this);
+            Initialize();
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GraphicsDevice" /> class.
+        /// </summary>
+        /// <param name="adapter">The graphics adapter.</param>
+        /// <param name="graphicsProfile">The graphics profile.</param>
+        /// <param name="presentationParameters">The presentation options.</param>
+        /// <exception cref="ArgumentNullException">
+        /// <paramref name="presentationParameters"/> is <see langword="null"/>.
+        /// </exception>
+        public GraphicsDevice(GraphicsAdapter adapter, GraphicsProfile graphicsProfile, PresentationParameters presentationParameters)
+        {
+            if (adapter == null)
+                throw new ArgumentNullException("adapter");
+            if (!adapter.IsProfileSupported(graphicsProfile))
+                throw new NoSuitableGraphicsDeviceException(String.Format("Adapter '{0}' does not support the {1} profile.", adapter.Description, graphicsProfile));
+            if (presentationParameters == null)
+                throw new ArgumentNullException("presentationParameters");
+            Adapter = adapter;
+            PresentationParameters = presentationParameters;
+            _graphicsProfile = graphicsProfile;
+            Setup();
+            GraphicsCapabilities = new GraphicsCapabilities();
+            GraphicsCapabilities.Initialize(this);
+
+            Initialize();
+        }
+
+        private void Setup()
+        {
+#if DEBUG
+            if (DisplayMode == null)
+            {
+                throw new Exception(
+                    "Unable to determine the current display mode.  This can indicate that the " +
+                    "game is not configured to be HiDPI aware under Windows 10 or later.  See " +
+                    "https://github.com/MonoGame/MonoGame/issues/5040 for more information.");
+            }
+#endif
+
+            // Initialize the main viewport
+            _viewport = new Viewport (0, 0,
+			                         DisplayMode.Width, DisplayMode.Height);
+			_viewport.MaxDepth = 1.0f;
+
+            PlatformSetup();
+
+            VertexTextures = new TextureCollection(this, MaxVertexTextureSlots, true);
+            VertexSamplerStates = new SamplerStateCollection(this, MaxVertexTextureSlots, true);
+
+            Textures = new TextureCollection(this, MaxTextureSlots, false);
+            SamplerStates = new SamplerStateCollection(this, MaxTextureSlots, false);
+
+            _blendStateAdditive = BlendState.Additive.Clone();
+            _blendStateAlphaBlend = BlendState.AlphaBlend.Clone();
+            _blendStateNonPremultiplied = BlendState.NonPremultiplied.Clone();
+            _blendStateOpaque = BlendState.Opaque.Clone();
+
+            BlendState = BlendState.Opaque;
+
+            _depthStencilStateDefault = DepthStencilState.Default.Clone();
+            _depthStencilStateDepthRead = DepthStencilState.DepthRead.Clone();
+            _depthStencilStateNone = DepthStencilState.None.Clone();
+
+            DepthStencilState = DepthStencilState.Default;
+
+            _rasterizerStateCullClockwise = RasterizerState.CullClockwise.Clone();
+            _rasterizerStateCullCounterClockwise = RasterizerState.CullCounterClockwise.Clone();
+            _rasterizerStateCullNone = RasterizerState.CullNone.Clone();
+
+            RasterizerState = RasterizerState.CullCounterClockwise;
+
+            EffectCache = new Dictionary<int, Effect>();
+        }
+
+        ~GraphicsDevice()
+        {
+            Dispose(false);
+        }
+
+        internal int GetClampedMultisampleCount(int multiSampleCount)
+        {
+            if (multiSampleCount > 1)
+            {
+                // Round down MultiSampleCount to the nearest power of two
+                // hack from http://stackoverflow.com/a/2681094
+                // Note: this will return an incorrect, but large value
+                // for very large numbers. That doesn't matter because
+                // the number will get clamped below anyway in this case.
+                var msc = multiSampleCount;
+                msc = msc | (msc >> 1);
+                msc = msc | (msc >> 2);
+                msc = msc | (msc >> 4);
+                msc -= (msc >> 1);
+                // and clamp it to what the device can handle
+                if (msc > GraphicsCapabilities.MaxMultiSampleCount)
+                    msc = GraphicsCapabilities.MaxMultiSampleCount;
+
+                return msc;
+            }
+            else return 0;
+        }
+
+        internal void Initialize()
+        {
+            PlatformInitialize();
+
+            // Force set the default render states.
+            _blendStateDirty = _depthStencilStateDirty = _rasterizerStateDirty = true;
+            BlendState = BlendState.Opaque;
+            DepthStencilState = DepthStencilState.Default;
+            RasterizerState = RasterizerState.CullCounterClockwise;
+
+            // Clear the texture and sampler collections forcing
+            // the state to be reapplied.
+            VertexTextures.Clear();
+            VertexSamplerStates.Clear();
+            Textures.Clear();
+            SamplerStates.Clear();
+
+            // Clear constant buffers
+            _vertexConstantBuffers.Clear();
+            _pixelConstantBuffers.Clear();
+
+            // Force set the buffers and shaders on next ApplyState() call
+            _vertexBuffers = new VertexBufferBindings(_maxVertexBufferSlots);
+            _vertexBuffersDirty = true;
+            _indexBufferDirty = true;
+            _vertexShaderDirty = true;
+            _pixelShaderDirty = true;
+
+            // Set the default scissor rect.
+            _scissorRectangleDirty = true;
+            ScissorRectangle = _viewport.Bounds;
+
+            // Set the default render target.
+            ApplyRenderTargets(null);
+        }
+
+        public RasterizerState RasterizerState
+        {
+            get
+            {
+                return _rasterizerState;
+            }
+
+            set
+            {
+                if (value == null)
+                    throw new ArgumentNullException("value");
+
+                // Don't set the same state twice!
+                if (_rasterizerState == value)
+                    return;
+
+                if (!value.DepthClipEnable && !GraphicsCapabilities.SupportsDepthClamp)
+                    throw new InvalidOperationException("Cannot set RasterizerState.DepthClipEnable to false on this graphics device");
+
+                _rasterizerState = value;
+
+                // Static state properties never actually get bound;
+                // instead we use our GraphicsDevice-specific version of them.
+                var newRasterizerState = _rasterizerState;
+                if (ReferenceEquals(_rasterizerState, RasterizerState.CullClockwise))
+                    newRasterizerState = _rasterizerStateCullClockwise;
+                else if (ReferenceEquals(_rasterizerState, RasterizerState.CullCounterClockwise))
+                    newRasterizerState = _rasterizerStateCullCounterClockwise;
+                else if (ReferenceEquals(_rasterizerState, RasterizerState.CullNone))
+                    newRasterizerState = _rasterizerStateCullNone;
+
+                newRasterizerState.BindToGraphicsDevice(this);
+
+                _actualRasterizerState = newRasterizerState;
+
+                _rasterizerStateDirty = true;
+            }
+        }
+
+        /// <summary>
+        /// The color used as blend factor when alpha blending.
+        /// </summary>
+        /// <remarks>
+        /// When only changing BlendFactor, use this rather than <see cref="Graphics.BlendState.BlendFactor"/> to
+        /// only update BlendFactor so the whole BlendState does not have to be updated.
+        /// </remarks>
+        public Color BlendFactor
+        {
+            get { return _blendFactor; }
+            set
+            {
+                if (_blendFactor == value)
+                    return;
+                _blendFactor = value;
+                _blendFactorDirty = true;
+            }
+        }
+
+        public BlendState BlendState
+        {
+			get { return _blendState; }
+			set
+            {
+                if (value == null)
+                    throw new ArgumentNullException("value");
+
+                // Don't set the same state twice!
+                if (_blendState == value)
+                    return;
+
+				_blendState = value;
+
+                // Static state properties never actually get bound;
+                // instead we use our GraphicsDevice-specific version of them.
+                var newBlendState = _blendState;
+                if (ReferenceEquals(_blendState, BlendState.Additive))
+                    newBlendState = _blendStateAdditive;
+                else if (ReferenceEquals(_blendState, BlendState.AlphaBlend))
+                    newBlendState = _blendStateAlphaBlend;
+                else if (ReferenceEquals(_blendState, BlendState.NonPremultiplied))
+                    newBlendState = _blendStateNonPremultiplied;
+                else if (ReferenceEquals(_blendState, BlendState.Opaque))
+                    newBlendState = _blendStateOpaque;
+
+                // Blend state is now bound to a device... no one should
+                // be changing the state of the blend state object now!
+                newBlendState.BindToGraphicsDevice(this);
+
+                _actualBlendState = newBlendState;
+
+                BlendFactor = _actualBlendState.BlendFactor;
+
+                _blendStateDirty = true;
+            }
+		}
+
+        public DepthStencilState DepthStencilState
+        {
+            get { return _depthStencilState; }
+            set
+            {
+                if (value == null)
+                    throw new ArgumentNullException("value");
+
+                // Don't set the same state twice!
+                if (_depthStencilState == value)
+                    return;
+
+                _depthStencilState = value;
+
+                // Static state properties never actually get bound;
+                // instead we use our GraphicsDevice-specific version of them.
+                var newDepthStencilState = _depthStencilState;
+                if (ReferenceEquals(_depthStencilState, DepthStencilState.Default))
+                    newDepthStencilState = _depthStencilStateDefault;
+                else if (ReferenceEquals(_depthStencilState, DepthStencilState.DepthRead))
+                    newDepthStencilState = _depthStencilStateDepthRead;
+                else if (ReferenceEquals(_depthStencilState, DepthStencilState.None))
+                    newDepthStencilState = _depthStencilStateNone;
+
+                newDepthStencilState.BindToGraphicsDevice(this);
+
+                _actualDepthStencilState = newDepthStencilState;
+
+                _depthStencilStateDirty = true;
+            }
+        }
+
+        internal void ApplyState(bool applyShaders)
+        {
+            PlatformBeginApplyState();
+
+            PlatformApplyBlend();
+
+            if (_depthStencilStateDirty)
+            {
+                _actualDepthStencilState.PlatformApplyState(this);
+                _depthStencilStateDirty = false;
+            }
+
+            if (_rasterizerStateDirty)
+            {
+                _actualRasterizerState.PlatformApplyState(this);
+                _rasterizerStateDirty = false;
+            }
+
+            PlatformApplyState(applyShaders);
+        }
+
+        public void Clear(Color color)
+        {
+            var options = ClearOptions.Target;
+            options |= ClearOptions.DepthBuffer;
+            options |= ClearOptions.Stencil;
+            PlatformClear(options, color.ToVector4(), _viewport.MaxDepth, 0);
+
+            unchecked
+            {
+                _graphicsMetrics._clearCount++;
+            }
+        }
+
+        public void Clear(ClearOptions options, Color color, float depth, int stencil)
+        {
+            PlatformClear(options, color.ToVector4(), depth, stencil);
+
+            unchecked
+            {
+                _graphicsMetrics._clearCount++;
+            }
+        }
+
+		public void Clear(ClearOptions options, Vector4 color, float depth, int stencil)
+		{
+            PlatformClear(options, color, depth, stencil);
+
+            unchecked
+            {
+                _graphicsMetrics._clearCount++;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_isDisposed)
+            {
+                if (disposing)
+                {
+                    // Dispose of all remaining graphics resources before disposing of the graphics device
+                    lock (_resourcesLock)
+                    {
+                        foreach (var resource in _resources.ToArray())
+                        {
+                            var target = resource.Target as IDisposable;
+                            if (target != null)
+                                target.Dispose();
+                        }
+                        _resources.Clear();
+                    }
+
+                    // Clear the effect cache.
+                    EffectCache.Clear();
+
+                    _blendState = null;
+                    _actualBlendState = null;
+                    _blendStateAdditive.Dispose();
+                    _blendStateAlphaBlend.Dispose();
+                    _blendStateNonPremultiplied.Dispose();
+                    _blendStateOpaque.Dispose();
+
+                    _depthStencilState = null;
+                    _actualDepthStencilState = null;
+                    _depthStencilStateDefault.Dispose();
+                    _depthStencilStateDepthRead.Dispose();
+                    _depthStencilStateNone.Dispose();
+
+                    _rasterizerState = null;
+                    _actualRasterizerState = null;
+                    _rasterizerStateCullClockwise.Dispose();
+                    _rasterizerStateCullCounterClockwise.Dispose();
+                    _rasterizerStateCullNone.Dispose();
+
+                    PlatformDispose();
+                }
+
+                _isDisposed = true;
+                EventHelpers.Raise(this, Disposing, EventArgs.Empty);
+            }
+        }
+
+        internal void AddResourceReference(WeakReference resourceReference)
+        {
+            lock (_resourcesLock)
+            {
+                _resources.Add(resourceReference);
+            }
+        }
+
+        internal void RemoveResourceReference(WeakReference resourceReference)
+        {
+            lock (_resourcesLock)
+            {
+                _resources.Remove(resourceReference);
+            }
+        }
+
+        public void Present()
+        {
+            // We cannot present with a RT set on the device.
+            if (_currentRenderTargetCount != 0)
+                throw new InvalidOperationException("Cannot call Present when a render target is active.");
+
+            _graphicsMetrics = new GraphicsMetrics();
+            PlatformPresent();
+        }
+
+        /*
+        public void Present(Rectangle? sourceRectangle, Rectangle? destinationRectangle, IntPtr overrideWindowHandle)
+        {
+            throw new NotImplementedException();
+        }
+        */
+
+        partial void PlatformReset();
+
+        public void Reset()
+        {
+            PlatformReset();
+
+            EventHelpers.Raise(this, DeviceResetting, EventArgs.Empty);
+
+            // Update the back buffer.
+            OnPresentationChanged();
+            
+            EventHelpers.Raise(this, PresentationChanged, new PresentationEventArgs(PresentationParameters));
+            EventHelpers.Raise(this, DeviceReset, EventArgs.Empty);
+       }
+
+        public void Reset(PresentationParameters presentationParameters)
+        {
+            if (presentationParameters == null)
+                throw new ArgumentNullException("presentationParameters");
+
+            PresentationParameters = presentationParameters;
+            Reset();
+        }
+
+        /// <summary>
+        /// Trigger the DeviceResetting event
+        /// Currently internal to allow the various platforms to send the event at the appropriate time.
+        /// </summary>
+        internal void OnDeviceResetting()
+        {
+            EventHelpers.Raise(this, DeviceResetting, EventArgs.Empty);
+
+            lock (_resourcesLock)
+            {
+                foreach (var resource in _resources)
+                {
+                    var target = resource.Target as GraphicsResource;
+                    if (target != null)
+                        target.GraphicsDeviceResetting();
+                }
+
+                // Remove references to resources that have been garbage collected.
+                _resources.RemoveAll(wr => !wr.IsAlive);
+            }
+        }
+
+        /// <summary>
+        /// Trigger the DeviceReset event to allow games to be notified of a device reset.
+        /// Currently internal to allow the various platforms to send the event at the appropriate time.
+        /// </summary>
+        internal void OnDeviceReset()
+        {
+            EventHelpers.Raise(this, DeviceReset, EventArgs.Empty);
+        }
+
+        public DisplayMode DisplayMode
+        {
+            get
+            {
+                return Adapter.CurrentDisplayMode;
+            }
+        }
+
+        public GraphicsDeviceStatus GraphicsDeviceStatus
+        {
+            get
+            {
+                return GraphicsDeviceStatus.Normal;
+            }
+        }
+
+        public PresentationParameters PresentationParameters
+        {
+            get;
+            private set;
+        }
+
+        public Viewport Viewport
+        {
+            get
+            {
+                return _viewport;
+            }
+
+            set
+            {
+                _viewport = value;
+                PlatformSetViewport(ref value);
+            }
+        }
+
+        private readonly GraphicsProfile _graphicsProfile;
+        public GraphicsProfile GraphicsProfile
+        {
+            get { return _graphicsProfile; }
+        }
+
+        public Rectangle ScissorRectangle
+        {
+            get
+            {
+                return _scissorRectangle;
+            }
+
+            set
+            {
+                if (_scissorRectangle == value)
+                    return;
+
+                _scissorRectangle = value;
+                _scissorRectangleDirty = true;
+            }
+        }
+
+        public int RenderTargetCount
+        {
+            get
+            {
+                return _currentRenderTargetCount;
+            }
+        }
+
+		public void SetRenderTarget(RenderTarget2D renderTarget)
+		{
+			if (renderTarget == null)
+		    {
+                SetRenderTargets(null);
+		    }
+			else
+			{
+				_tempRenderTargetBinding[0] = new RenderTargetBinding(renderTarget);
+				SetRenderTargets(_tempRenderTargetBinding);
+			}
+		}
+
+        public void SetRenderTarget(RenderTargetCube renderTarget, CubeMapFace cubeMapFace)
+        {
+            if (renderTarget == null)
+            {
+                SetRenderTargets(null);
+            }
+            else
+            {
+                _tempRenderTargetBinding[0] = new RenderTargetBinding(renderTarget, cubeMapFace);
+                SetRenderTargets(_tempRenderTargetBinding);
+            }
+        }
+
+		public void SetRenderTargets(params RenderTargetBinding[] renderTargets)
+		{
+            // Avoid having to check for null and zero length.
+            var renderTargetCount = 0;
+            if (renderTargets != null)
+            {
+                renderTargetCount = renderTargets.Length;
+                if (renderTargetCount == 0)
+                {
+                    renderTargets = null;
+                }
+            }
+
+            // Try to early out if the current and new bindings are equal.
+            if (_currentRenderTargetCount == renderTargetCount)
+            {
+                var isEqual = true;
+                for (var i = 0; i < _currentRenderTargetCount; i++)
+                {
+                    if (_currentRenderTargetBindings[i].RenderTarget != renderTargets[i].RenderTarget ||
+                        _currentRenderTargetBindings[i].ArraySlice != renderTargets[i].ArraySlice)
+                    {
+                        isEqual = false;
+                        break;
+                    }
+                }
+
+                if (isEqual)
+                    return;
+            }
+
+            ApplyRenderTargets(renderTargets);
+
+            if (renderTargetCount == 0)
+            {
+                unchecked
+                {
+                    _graphicsMetrics._targetCount++;
+                }
+            }
+            else
+            {
+                unchecked
+                {
+                    _graphicsMetrics._targetCount += renderTargetCount;
+                }
+            }
+        }
+
+        internal void ApplyRenderTargets(RenderTargetBinding[] renderTargets)
+        {
+            var clearTarget = false;
+
+            PlatformResolveRenderTargets();
+
+            // Clear the current bindings.
+            Array.Clear(_currentRenderTargetBindings, 0, _currentRenderTargetBindings.Length);
+
+            int renderTargetWidth;
+            int renderTargetHeight;
+            if (renderTargets == null)
+            {
+                _currentRenderTargetCount = 0;
+
+                PlatformApplyDefaultRenderTarget();
+                clearTarget = PresentationParameters.RenderTargetUsage == RenderTargetUsage.DiscardContents;
+
+                renderTargetWidth = PresentationParameters.BackBufferWidth;
+                renderTargetHeight = PresentationParameters.BackBufferHeight;
+            }
+			else
+			{
+                // Copy the new bindings.
+                Array.Copy(renderTargets, _currentRenderTargetBindings, renderTargets.Length);
+                _currentRenderTargetCount = renderTargets.Length;
+
+                var renderTarget = PlatformApplyRenderTargets();
+
+                // We clear the render target if asked.
+                clearTarget = renderTarget.RenderTargetUsage == RenderTargetUsage.DiscardContents;
+
+                renderTargetWidth = renderTarget.Width;
+                renderTargetHeight = renderTarget.Height;
+            }
+
+            // Set the viewport to the size of the first render target.
+            Viewport = new Viewport(0, 0, renderTargetWidth, renderTargetHeight);
+
+            // Set the scissor rectangle to the size of the first render target.
+            ScissorRectangle = new Rectangle(0, 0, renderTargetWidth, renderTargetHeight);
+
+            // In XNA 4, because of hardware limitations on Xbox, when
+            // a render target doesn't have PreserveContents as its usage
+            // it is cleared before being rendered to.
+            if (clearTarget)
+                Clear(DiscardColor);
+        }
+
+		public RenderTargetBinding[] GetRenderTargets()
+		{
+            // Return a correctly sized copy our internal array.
+            var bindings = new RenderTargetBinding[_currentRenderTargetCount];
+            Array.Copy(_currentRenderTargetBindings, bindings, _currentRenderTargetCount);
+            return bindings;
+		}
+
+        public void GetRenderTargets(RenderTargetBinding[] outTargets)
+        {
+            Debug.Assert(outTargets.Length == _currentRenderTargetCount, "Invalid outTargets array length!");
+            Array.Copy(_currentRenderTargetBindings, outTargets, _currentRenderTargetCount);
+        }
+
+        public void SetVertexBuffer(VertexBuffer vertexBuffer)
+        {
+            _vertexBuffersDirty |= (vertexBuffer == null)
+                                   ? _vertexBuffers.Clear()
+                                   : _vertexBuffers.Set(vertexBuffer, 0);
+        }
+
+        public void SetVertexBuffer(VertexBuffer vertexBuffer, int vertexOffset)
+        {
+            // Validate vertexOffset.
+            if (vertexOffset < 0
+                || vertexBuffer == null && vertexOffset != 0
+                || vertexBuffer != null && vertexOffset >= vertexBuffer.VertexCount)
+            {
+                throw new ArgumentOutOfRangeException("vertexOffset");
+            }
+
+            _vertexBuffersDirty |= (vertexBuffer == null)
+                                   ? _vertexBuffers.Clear()
+                                   : _vertexBuffers.Set(vertexBuffer, vertexOffset);
+        }
+
+        public void SetVertexBuffers(params VertexBufferBinding[] vertexBuffers)
+        {
+            if (vertexBuffers == null || vertexBuffers.Length == 0)
+            {
+                _vertexBuffersDirty |= _vertexBuffers.Clear();
+            }
+            else
+            {
+                if (vertexBuffers.Length > _maxVertexBufferSlots)
+                {
+                    var message = string.Format(CultureInfo.InvariantCulture, "Max number of vertex buffers is {0}.", _maxVertexBufferSlots);
+                    throw new ArgumentOutOfRangeException("vertexBuffers", message);
+                }
+
+                _vertexBuffersDirty |= _vertexBuffers.Set(vertexBuffers);
+            }
+        }
+
+        private void SetIndexBuffer(IndexBuffer indexBuffer)
+        {
+            if (_indexBuffer == indexBuffer)
+                return;
+
+            _indexBuffer = indexBuffer;
+            _indexBufferDirty = true;
+        }
+
+        public IndexBuffer Indices { set { SetIndexBuffer(value); } get { return _indexBuffer; } }
+
+        internal Shader VertexShader
+        {
+            get { return _vertexShader; }
+
+            set
+            {
+                if (_vertexShader == value)
+                    return;
+
+                _vertexShader = value;
+                _vertexConstantBuffers.Clear();
+                _vertexShaderDirty = true;
+            }
+        }
+
+        internal Shader PixelShader
+        {
+            get { return _pixelShader; }
+
+            set
+            {
+                if (_pixelShader == value)
+                    return;
+
+                _pixelShader = value;
+                _pixelConstantBuffers.Clear();
+                _pixelShaderDirty = true;
+            }
+        }
+
+        internal void SetConstantBuffer(ShaderStage stage, int slot, ConstantBuffer buffer)
+        {
+            if (stage == ShaderStage.Vertex)
+                _vertexConstantBuffers[slot] = buffer;
+            else
+                _pixelConstantBuffers[slot] = buffer;
+        }
+
+        public bool ResourcesLost { get; set; }
+
+        /// <summary>
+        /// Draw geometry by indexing into the vertex buffer.
+        /// </summary>
+        /// <param name="primitiveType">The type of primitives in the index buffer.</param>
+        /// <param name="baseVertex">Used to offset the vertex range indexed from the vertex buffer.</param>
+        /// <param name="minVertexIndex">This is unused and remains here only for XNA API compatibility.</param>
+        /// <param name="numVertices">This is unused and remains here only for XNA API compatibility.</param>
+        /// <param name="startIndex">The index within the index buffer to start drawing from.</param>
+        /// <param name="primitiveCount">The number of primitives to render from the index buffer.</param>
+        /// <remarks>Note that minVertexIndex and numVertices are unused in MonoGame and will be ignored.</remarks>
+        [Obsolete("Use DrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int startIndex, int primitiveCount) instead. In future versions this method can be removed.")]
+        public void DrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int minVertexIndex, int numVertices, int startIndex, int primitiveCount)
+        {
+            DrawIndexedPrimitives(primitiveType, baseVertex, startIndex, primitiveCount);
+        }
+
+        /// <summary>
+        /// Draw geometry by indexing into the vertex buffer.
+        /// </summary>
+        /// <param name="primitiveType">The type of primitives in the index buffer.</param>
+        /// <param name="baseVertex">Used to offset the vertex range indexed from the vertex buffer.</param>
+        /// <param name="startIndex">The index within the index buffer to start drawing from.</param>
+        /// <param name="primitiveCount">The number of primitives to render from the index buffer.</param>
+        public void DrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int startIndex, int primitiveCount)
+        {
+            if (_vertexShader == null)
+                throw new InvalidOperationException("Vertex shader must be set before calling DrawIndexedPrimitives.");
+
+            if (_vertexBuffers.Count == 0)
+                throw new InvalidOperationException("Vertex buffer must be set before calling DrawIndexedPrimitives.");
+
+            if (_indexBuffer == null)
+                throw new InvalidOperationException("Index buffer must be set before calling DrawIndexedPrimitives.");
+
+            if (primitiveCount <= 0)
+                throw new ArgumentOutOfRangeException("primitiveCount");
+
+            PlatformDrawIndexedPrimitives(primitiveType, baseVertex, startIndex, primitiveCount);
+
+            unchecked
+            {
+                _graphicsMetrics._drawCount++;
+                _graphicsMetrics._primitiveCount += primitiveCount;
+            }
+        }
+
+        /// <summary>
+        /// Draw primitives of the specified type from the data in an array of vertices without indexing.
+        /// </summary>
+        /// <typeparam name="T">The type of the vertices.</typeparam>
+        /// <param name="primitiveType">The type of primitives to draw with the vertices.</param>
+        /// <param name="vertexData">An array of vertices to draw.</param>
+        /// <param name="vertexOffset">The index in the array of the first vertex that should be rendered.</param>
+        /// <param name="primitiveCount">The number of primitives to draw.</param>
+        /// <remarks>The <see cref="VertexDeclaration"/> will be found by getting <see cref="IVertexType.VertexDeclaration"/>
+        /// from an instance of <typeparamref name="T"/> and cached for subsequent calls.</remarks>
+        public void DrawUserPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int primitiveCount) where T : struct, IVertexType
+        {
+            DrawUserPrimitives(primitiveType, vertexData, vertexOffset, primitiveCount, VertexDeclarationCache<T>.VertexDeclaration);
+        }
+
+        /// <summary>
+        /// Draw primitives of the specified type from the data in the given array of vertices without indexing.
+        /// </summary>
+        /// <typeparam name="T">The type of the vertices.</typeparam>
+        /// <param name="primitiveType">The type of primitives to draw with the vertices.</param>
+        /// <param name="vertexData">An array of vertices to draw.</param>
+        /// <param name="vertexOffset">The index in the array of the first vertex that should be rendered.</param>
+        /// <param name="primitiveCount">The number of primitives to draw.</param>
+        /// <param name="vertexDeclaration">The layout of the vertices.</param>
+        public void DrawUserPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int primitiveCount, VertexDeclaration vertexDeclaration) where T : struct
+        {
+            if (vertexData == null)
+                throw new ArgumentNullException("vertexData");
+
+            if (vertexData.Length == 0)
+                throw new ArgumentOutOfRangeException("vertexData");
+
+            if (vertexOffset < 0 || vertexOffset >= vertexData.Length)
+                throw new ArgumentOutOfRangeException("vertexOffset");
+
+            if (primitiveCount <= 0)
+                throw new ArgumentOutOfRangeException("primitiveCount");
+
+            var vertexCount = GetElementCountArray(primitiveType, primitiveCount);
+
+            if (vertexOffset + vertexCount > vertexData.Length)
+                throw new ArgumentOutOfRangeException("primitiveCount");
+
+            if (vertexDeclaration == null)
+                throw new ArgumentNullException("vertexDeclaration");
+
+            PlatformDrawUserPrimitives<T>(primitiveType, vertexData, vertexOffset, vertexDeclaration, vertexCount);
+
+            unchecked
+            {
+                _graphicsMetrics._drawCount++;
+                _graphicsMetrics._primitiveCount += primitiveCount;
+            }
+        }
+
+        /// <summary>
+        /// Draw primitives of the specified type from the currently bound vertexbuffers without indexing.
+        /// </summary>
+        /// <param name="primitiveType">The type of primitives to draw.</param>
+        /// <param name="vertexStart">Index of the vertex to start at.</param>
+        /// <param name="primitiveCount">The number of primitives to draw.</param>
+        public void DrawPrimitives(PrimitiveType primitiveType, int vertexStart, int primitiveCount)
+        {
+            if (_vertexShader == null)
+                throw new InvalidOperationException("Vertex shader must be set before calling DrawPrimitives.");
+
+            if (_vertexBuffers.Count == 0)
+                throw new InvalidOperationException("Vertex buffer must be set before calling DrawPrimitives.");
+
+            if (primitiveCount <= 0)
+                throw new ArgumentOutOfRangeException("primitiveCount");
+
+            var vertexCount = GetElementCountArray(primitiveType, primitiveCount);
+
+            PlatformDrawPrimitives(primitiveType, vertexStart, vertexCount);
+
+            unchecked
+            {
+                _graphicsMetrics._drawCount++;
+                _graphicsMetrics._primitiveCount +=  primitiveCount;
+            }
+        }
+
+        /// <summary>
+        /// Draw primitives of the specified type by indexing into the given array of vertices with 16-bit indices.
+        /// </summary>
+        /// <typeparam name="T">The type of the vertices.</typeparam>
+        /// <param name="primitiveType">The type of primitives to draw with the vertices.</param>
+        /// <param name="vertexData">An array of vertices to draw.</param>
+        /// <param name="vertexOffset">The index in the array of the first vertex to draw.</param>
+        /// <param name="indexOffset">The index in the array of indices of the first index to use</param>
+        /// <param name="primitiveCount">The number of primitives to draw.</param>
+        /// <param name="numVertices">The number of vertices to draw.</param>
+        /// <param name="indexData">The index data.</param>
+        /// <remarks>The <see cref="VertexDeclaration"/> will be found by getting <see cref="IVertexType.VertexDeclaration"/>
+        /// from an instance of <typeparamref name="T"/> and cached for subsequent calls.</remarks>
+        /// <remarks>All indices in the vertex buffer are interpreted relative to the specified <paramref name="vertexOffset"/>.
+        /// For example a value of zero in the array of indices points to the vertex at index <paramref name="vertexOffset"/>
+        /// in the array of vertices.</remarks>
+        public void DrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices, short[] indexData, int indexOffset, int primitiveCount) where T : struct, IVertexType
+        {
+            DrawUserIndexedPrimitives<T>(primitiveType, vertexData, vertexOffset, numVertices, indexData, indexOffset, primitiveCount, VertexDeclarationCache<T>.VertexDeclaration);
+        }
+
+        /// <summary>
+        /// Draw primitives of the specified type by indexing into the given array of vertices with 16-bit indices.
+        /// </summary>
+        /// <typeparam name="T">The type of the vertices.</typeparam>
+        /// <param name="primitiveType">The type of primitives to draw with the vertices.</param>
+        /// <param name="vertexData">An array of vertices to draw.</param>
+        /// <param name="vertexOffset">The index in the array of the first vertex to draw.</param>
+        /// <param name="indexOffset">The index in the array of indices of the first index to use</param>
+        /// <param name="primitiveCount">The number of primitives to draw.</param>
+        /// <param name="numVertices">The number of vertices to draw.</param>
+        /// <param name="indexData">The index data.</param>
+        /// <param name="vertexDeclaration">The layout of the vertices.</param>
+        /// <remarks>All indices in the vertex buffer are interpreted relative to the specified <paramref name="vertexOffset"/>.
+        /// For example a value of zero in the array of indices points to the vertex at index <paramref name="vertexOffset"/>
+        /// in the array of vertices.</remarks>
+        public void DrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices, short[] indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration) where T : struct
+        {
+            // These parameter checks are a duplicate of the checks in the int[] overload of DrawUserIndexedPrimitives.
+            // Inlined here for efficiency.
+
+            if (vertexData == null || vertexData.Length == 0)
+                throw new ArgumentNullException("vertexData");
+
+            if (vertexOffset < 0 || vertexOffset >= vertexData.Length)
+                throw new ArgumentOutOfRangeException("vertexOffset");
+
+            if (numVertices <= 0 || numVertices > vertexData.Length)
+                throw new ArgumentOutOfRangeException("numVertices");
+
+            if (vertexOffset + numVertices > vertexData.Length)
+                throw new ArgumentOutOfRangeException("numVertices");
+
+            if (indexData == null || indexData.Length == 0)
+                throw new ArgumentNullException("indexData");
+
+            if (indexOffset < 0 || indexOffset >= indexData.Length)
+                throw new ArgumentOutOfRangeException("indexOffset");
+
+            if (primitiveCount <= 0)
+                throw new ArgumentOutOfRangeException("primitiveCount");
+
+            if (indexOffset + GetElementCountArray(primitiveType, primitiveCount) > indexData.Length)
+                throw new ArgumentOutOfRangeException("primitiveCount");
+
+            if (vertexDeclaration == null)
+                throw new ArgumentNullException("vertexDeclaration");
+
+            if (vertexDeclaration.VertexStride < ReflectionHelpers.SizeOf<T>.Get())
+                throw new ArgumentOutOfRangeException("vertexDeclaration", "Vertex stride of vertexDeclaration should be at least as big as the stride of the actual vertices.");
+
+            PlatformDrawUserIndexedPrimitives<T>(primitiveType, vertexData, vertexOffset, numVertices, indexData, indexOffset, primitiveCount, vertexDeclaration);
+
+            unchecked
+            {
+                _graphicsMetrics._drawCount++;
+                _graphicsMetrics._primitiveCount +=  primitiveCount;
+            }
+        }
+
+        /// <summary>
+        /// Draw primitives of the specified type by indexing into the given array of vertices with 32-bit indices.
+        /// </summary>
+        /// <typeparam name="T">The type of the vertices.</typeparam>
+        /// <param name="primitiveType">The type of primitives to draw with the vertices.</param>
+        /// <param name="vertexData">An array of vertices to draw.</param>
+        /// <param name="vertexOffset">The index in the array of the first vertex to draw.</param>
+        /// <param name="indexOffset">The index in the array of indices of the first index to use</param>
+        /// <param name="primitiveCount">The number of primitives to draw.</param>
+        /// <param name="numVertices">The number of vertices to draw.</param>
+        /// <param name="indexData">The index data.</param>
+        /// <remarks>The <see cref="VertexDeclaration"/> will be found by getting <see cref="IVertexType.VertexDeclaration"/>
+        /// from an instance of <typeparamref name="T"/> and cached for subsequent calls.</remarks>
+        /// <remarks>All indices in the vertex buffer are interpreted relative to the specified <paramref name="vertexOffset"/>.
+        /// For example a value of zero in the array of indices points to the vertex at index <paramref name="vertexOffset"/>
+        /// in the array of vertices.</remarks>
+        public void DrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices, int[] indexData, int indexOffset, int primitiveCount) where T : struct, IVertexType
+        {
+            DrawUserIndexedPrimitives<T>(primitiveType, vertexData, vertexOffset, numVertices, indexData, indexOffset, primitiveCount, VertexDeclarationCache<T>.VertexDeclaration);
+        }
+
+        /// <summary>
+        /// Draw primitives of the specified type by indexing into the given array of vertices with 32-bit indices.
+        /// </summary>
+        /// <typeparam name="T">The type of the vertices.</typeparam>
+        /// <param name="primitiveType">The type of primitives to draw with the vertices.</param>
+        /// <param name="vertexData">An array of vertices to draw.</param>
+        /// <param name="vertexOffset">The index in the array of the first vertex to draw.</param>
+        /// <param name="indexOffset">The index in the array of indices of the first index to use</param>
+        /// <param name="primitiveCount">The number of primitives to draw.</param>
+        /// <param name="numVertices">The number of vertices to draw.</param>
+        /// <param name="indexData">The index data.</param>
+        /// <param name="vertexDeclaration">The layout of the vertices.</param>
+        /// <remarks>All indices in the vertex buffer are interpreted relative to the specified <paramref name="vertexOffset"/>.
+        /// For example value of zero in the array of indices points to the vertex at index <paramref name="vertexOffset"/>
+        /// in the array of vertices.</remarks>
+        public void DrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices, int[] indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration) where T : struct
+        {
+            // These parameter checks are a duplicate of the checks in the short[] overload of DrawUserIndexedPrimitives.
+            // Inlined here for efficiency.
+
+            if (vertexData == null || vertexData.Length == 0)
+                throw new ArgumentNullException("vertexData");
+
+            if (vertexOffset < 0 || vertexOffset >= vertexData.Length)
+                throw new ArgumentOutOfRangeException("vertexOffset");
+
+            if (numVertices <= 0 || numVertices > vertexData.Length)
+                throw new ArgumentOutOfRangeException("numVertices");
+
+            if (vertexOffset + numVertices > vertexData.Length)
+                throw new ArgumentOutOfRangeException("numVertices");
+
+            if (indexData == null || indexData.Length == 0)
+                throw new ArgumentNullException("indexData");
+
+            if (indexOffset < 0 || indexOffset >= indexData.Length)
+                throw new ArgumentOutOfRangeException("indexOffset");
+
+            if (primitiveCount <= 0)
+                throw new ArgumentOutOfRangeException("primitiveCount");
+
+            if (indexOffset + GetElementCountArray(primitiveType, primitiveCount) > indexData.Length)
+                throw new ArgumentOutOfRangeException("primitiveCount");
+
+            if (vertexDeclaration == null)
+                throw new ArgumentNullException("vertexDeclaration");
+
+            if (vertexDeclaration.VertexStride < ReflectionHelpers.SizeOf<T>.Get())
+                throw new ArgumentOutOfRangeException("vertexDeclaration", "Vertex stride of vertexDeclaration should be at least as big as the stride of the actual vertices.");
+
+            PlatformDrawUserIndexedPrimitives<T>(primitiveType, vertexData, vertexOffset, numVertices, indexData, indexOffset, primitiveCount, vertexDeclaration);
+            
+            unchecked
+            {
+                _graphicsMetrics._drawCount++;
+                _graphicsMetrics._primitiveCount +=  primitiveCount;
+            }
+        }
+
+        /// <summary>
+        /// Draw instanced geometry from the bound vertex buffers and index buffer.
+        /// </summary>
+        /// <param name="primitiveType">The type of primitives in the index buffer.</param>
+        /// <param name="baseVertex">Used to offset the vertex range indexed from the vertex buffer.</param>
+        /// <param name="minVertexIndex">This is unused and remains here only for XNA API compatibility.</param>
+        /// <param name="numVertices">This is unused and remains here only for XNA API compatibility.</param>
+        /// <param name="startIndex">The index within the index buffer to start drawing from.</param>
+        /// <param name="primitiveCount">The number of primitives in a single instance.</param>
+        /// <param name="instanceCount">The number of instances to render.</param>
+        /// <remarks>Note that minVertexIndex and numVertices are unused in MonoGame and will be ignored.</remarks>
+        [Obsolete("Use DrawInstancedPrimitives(PrimitiveType primitiveType, int baseVertex, int startIndex, int primitiveCount, int instanceCount) instead. In future versions this method can be removed.")]
+        public void DrawInstancedPrimitives(PrimitiveType primitiveType, int baseVertex, int minVertexIndex,
+                                            int numVertices, int startIndex, int primitiveCount, int instanceCount)
+        {
+            DrawInstancedPrimitives(primitiveType, baseVertex, startIndex, primitiveCount, instanceCount);
+        }
+
+        /// <summary>
+        /// Draw instanced geometry from the bound vertex buffers and index buffer.
+        /// </summary>
+        /// <param name="primitiveType">The type of primitives in the index buffer.</param>
+        /// <param name="baseVertex">Used to offset the vertex range indexed from the vertex buffer.</param>
+        /// <param name="startIndex">The index within the index buffer to start drawing from.</param>
+        /// <param name="primitiveCount">The number of primitives in a single instance.</param>
+        /// <param name="instanceCount">The number of instances to render.</param>
+        /// <remarks>Draw geometry with data from multiple bound vertex streams at different frequencies.</remarks>
+        public void DrawInstancedPrimitives(PrimitiveType primitiveType, int baseVertex, int startIndex, int primitiveCount, int instanceCount)
+        {
+            if (_vertexShader == null)
+                throw new InvalidOperationException("Vertex shader must be set before calling DrawInstancedPrimitives.");
+
+            if (_vertexBuffers.Count == 0)
+                throw new InvalidOperationException("Vertex buffer must be set before calling DrawInstancedPrimitives.");
+
+            if (_indexBuffer == null)
+                throw new InvalidOperationException("Index buffer must be set before calling DrawInstancedPrimitives.");
+
+            if (primitiveCount <= 0)
+                throw new ArgumentOutOfRangeException("primitiveCount");
+
+            PlatformDrawInstancedPrimitives(primitiveType, baseVertex, startIndex, primitiveCount, instanceCount);
+
+            unchecked
+            {
+                _graphicsMetrics._drawCount++;
+                _graphicsMetrics._primitiveCount += (primitiveCount * instanceCount);
+            }
+        }
+
+        /// <summary>
+        /// Gets the Pixel data of what is currently drawn on screen.
+        /// The format is whatever the current format of the backbuffer is.
+        /// </summary>
+        /// <typeparam name="T">A byte[] of size (ViewPort.Width * ViewPort.Height * 4)</typeparam>
+        public void GetBackBufferData<T>(T[] data) where T : struct
+        {
+            if (data == null)
+                throw new ArgumentNullException("data");
+            GetBackBufferData(null, data, 0, data.Length);
+        }
+
+        public void GetBackBufferData<T>(T[] data, int startIndex, int elementCount) where T : struct
+        {
+            GetBackBufferData(null, data, startIndex, elementCount);
+        }
+
+        public void GetBackBufferData<T>(Rectangle? rect, T[] data, int startIndex, int elementCount)
+            where T : struct
+        {
+            if (data == null)
+                throw new ArgumentNullException("data");
+
+            int width, height;
+            if (rect.HasValue)
+            {
+                var rectangle = rect.Value;
+                width = rectangle.Width;
+                height = rectangle.Height;
+
+                if (rectangle.X < 0 || rectangle.Y < 0 || rectangle.Width <= 0 || rectangle.Height <= 0 ||
+                    rectangle.Right > PresentationParameters.BackBufferWidth || rectangle.Top > PresentationParameters.BackBufferHeight)
+                    throw new ArgumentException("Rectangle must fit in BackBuffer dimensions");
+            }
+            else
+            {
+                width = PresentationParameters.BackBufferWidth;
+                height = PresentationParameters.BackBufferHeight;
+            }
+
+            var tSize = ReflectionHelpers.SizeOf<T>.Get();
+            var fSize = PresentationParameters.BackBufferFormat.GetSize();
+            if (tSize > fSize || fSize % tSize != 0)
+                throw new ArgumentException("Type T is of an invalid size for the format of this texture.", "T");
+            if (startIndex < 0 || startIndex >= data.Length)
+                throw new ArgumentException("startIndex must be at least zero and smaller than data.Length.", "startIndex");
+            if (data.Length < startIndex + elementCount)
+                throw new ArgumentException("The data array is too small.");
+            var dataByteSize = width * height * fSize;
+
+            if (elementCount * tSize != dataByteSize)
+                throw new ArgumentException(string.Format("elementCount is not the right size, " +
+                                            "elementCount * sizeof(T) is {0}, but data size is {1} bytes.",
+                                            elementCount * tSize, dataByteSize), "elementCount");
+
+            PlatformGetBackBufferData(rect, data, startIndex, elementCount);
+        }
+
+        private static int GetElementCountArray(PrimitiveType primitiveType, int primitiveCount)
+        {
+            switch (primitiveType)
+            {
+                case PrimitiveType.LineList:
+                    return primitiveCount * 2;
+                case PrimitiveType.LineStrip:
+                    return primitiveCount + 1;
+                case PrimitiveType.TriangleList:
+                    return primitiveCount * 3;
+                case PrimitiveType.TriangleStrip:
+                    return primitiveCount + 2;
+            }
+
+            throw new NotSupportedException();
+        }
+
+        // uniformly scales down the given rectangle by 10%
+        internal static Rectangle GetDefaultTitleSafeArea(int x, int y, int width, int height)
+        {
+            var marginX = (width + 19) / 20;
+            var marginY = (height + 19) / 20;
+            x += marginX;
+            y += marginY;
+
+            width -= marginX * 2;
+            height -= marginY * 2;
+            return new Rectangle(x, y, width, height);
+        }
+
+        internal static Rectangle GetTitleSafeArea(int x, int y, int width, int height)
+        {
+            return PlatformGetTitleSafeArea(x, y, width, height);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsDeviceStatus.cs b/MonoGame.Framework/Graphics/GraphicsDeviceStatus.cs
new file mode 100644
index 00000000000..d60f2ffa00b
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsDeviceStatus.cs
@@ -0,0 +1,26 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Describes the status of the <see cref="GraphicsDevice"/>.
+    /// </summary>
+    public enum GraphicsDeviceStatus
+    {
+        /// <summary>
+        /// The device is normal.
+        /// </summary>
+        Normal,
+        /// <summary>
+        /// The device has been lost.
+        /// </summary>
+        Lost,
+        /// <summary>
+        /// The device has not been reset.
+        /// </summary>
+        NotReset
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/GraphicsExtensions.cs b/MonoGame.Framework/Graphics/GraphicsExtensions.cs
new file mode 100644
index 00000000000..2cc9a9a7757
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsExtensions.cs
@@ -0,0 +1,947 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+
+#if OPENGL
+#if DESKTOPGL || GLES
+using MonoGame.OpenGL;
+using GLPixelFormat = MonoGame.OpenGL.PixelFormat;
+using PixelFormat = MonoGame.OpenGL.PixelFormat;
+#elif ANGLE
+using OpenTK.Graphics;
+#endif
+#endif
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    static class GraphicsExtensions
+    {
+#if OPENGL
+        public static int OpenGLNumberOfElements(this VertexElementFormat elementFormat)
+        {
+            switch (elementFormat)
+            {
+                case VertexElementFormat.Single:
+                    return 1;
+
+                case VertexElementFormat.Vector2:
+                    return 2;
+
+                case VertexElementFormat.Vector3:
+                    return 3;
+
+                case VertexElementFormat.Vector4:
+                    return 4;
+
+                case VertexElementFormat.Color:
+                    return 4;
+
+                case VertexElementFormat.Byte4:
+                    return 4;
+
+                case VertexElementFormat.Short2:
+                    return 2;
+
+                case VertexElementFormat.Short4:
+                    return 4;
+
+                case VertexElementFormat.NormalizedShort2:
+                    return 2;
+
+                case VertexElementFormat.NormalizedShort4:
+                    return 4;
+
+                case VertexElementFormat.HalfVector2:
+                    return 2;
+
+                case VertexElementFormat.HalfVector4:
+                    return 4;
+            }
+
+            throw new ArgumentException();
+        }
+
+        public static VertexPointerType OpenGLVertexPointerType(this VertexElementFormat elementFormat)
+        {
+            switch (elementFormat)
+            {
+                case VertexElementFormat.Single:
+                    return VertexPointerType.Float;
+
+                case VertexElementFormat.Vector2:
+                    return VertexPointerType.Float;
+
+                case VertexElementFormat.Vector3:
+                    return VertexPointerType.Float;
+
+                case VertexElementFormat.Vector4:
+                    return VertexPointerType.Float;
+
+                case VertexElementFormat.Color:
+                    return VertexPointerType.Short;
+
+                case VertexElementFormat.Byte4:
+                    return VertexPointerType.Short;
+
+                case VertexElementFormat.Short2:
+                    return VertexPointerType.Short;
+
+                case VertexElementFormat.Short4:
+                    return VertexPointerType.Short;
+
+                case VertexElementFormat.NormalizedShort2:
+                    return VertexPointerType.Short;
+
+                case VertexElementFormat.NormalizedShort4:
+                    return VertexPointerType.Short;
+
+                case VertexElementFormat.HalfVector2:
+                    return VertexPointerType.Float;
+
+                case VertexElementFormat.HalfVector4:
+                    return VertexPointerType.Float;
+            }
+
+            throw new ArgumentException();
+        }
+
+		public static VertexAttribPointerType OpenGLVertexAttribPointerType(this VertexElementFormat elementFormat)
+        {
+            switch (elementFormat)
+            {
+                case VertexElementFormat.Single:
+                    return VertexAttribPointerType.Float;
+
+                case VertexElementFormat.Vector2:
+                    return VertexAttribPointerType.Float;
+
+                case VertexElementFormat.Vector3:
+                    return VertexAttribPointerType.Float;
+
+                case VertexElementFormat.Vector4:
+                    return VertexAttribPointerType.Float;
+
+                case VertexElementFormat.Color:
+					return VertexAttribPointerType.UnsignedByte;
+
+                case VertexElementFormat.Byte4:
+					return VertexAttribPointerType.UnsignedByte;
+
+                case VertexElementFormat.Short2:
+                    return VertexAttribPointerType.Short;
+
+                case VertexElementFormat.Short4:
+                    return VertexAttribPointerType.Short;
+
+                case VertexElementFormat.NormalizedShort2:
+                    return VertexAttribPointerType.Short;
+
+                case VertexElementFormat.NormalizedShort4:
+                    return VertexAttribPointerType.Short;
+                
+#if WINDOWS || DESKTOPGL
+               case VertexElementFormat.HalfVector2:
+                    return VertexAttribPointerType.HalfFloat;
+
+                case VertexElementFormat.HalfVector4:
+                    return VertexAttribPointerType.HalfFloat;
+#endif
+            }
+
+            throw new ArgumentException();
+        }
+
+        public static bool OpenGLVertexAttribNormalized(this VertexElement element)
+        {
+            // TODO: This may or may not be the right behavor.  
+            //
+            // For instance the VertexElementFormat.Byte4 format is not supposed
+            // to be normalized, but this line makes it so.
+            //
+            // The question is in MS XNA are types normalized based on usage or
+            // normalized based to their format?
+            //
+            if (element.VertexElementUsage == VertexElementUsage.Color)
+                return true;
+
+            switch (element.VertexElementFormat)
+            {
+                case VertexElementFormat.NormalizedShort2:
+                case VertexElementFormat.NormalizedShort4:
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        public static ColorPointerType OpenGLColorPointerType(this VertexElementFormat elementFormat)
+        {
+            switch (elementFormat)
+            {
+                case VertexElementFormat.Single:
+                    return ColorPointerType.Float;
+
+                case VertexElementFormat.Vector2:
+                    return ColorPointerType.Float;
+
+                case VertexElementFormat.Vector3:
+                    return ColorPointerType.Float;
+
+                case VertexElementFormat.Vector4:
+                    return ColorPointerType.Float;
+
+                case VertexElementFormat.Color:
+                    return ColorPointerType.UnsignedByte;
+
+                case VertexElementFormat.Byte4:
+                    return ColorPointerType.UnsignedByte;
+
+                case VertexElementFormat.Short2:
+                    return ColorPointerType.Short;
+
+                case VertexElementFormat.Short4:
+                    return ColorPointerType.Short;
+
+                case VertexElementFormat.NormalizedShort2:
+                    return ColorPointerType.UnsignedShort;
+
+                case VertexElementFormat.NormalizedShort4:
+                    return ColorPointerType.UnsignedShort;
+				
+#if MONOMAC
+                case VertexElementFormat.HalfVector2:
+                    return ColorPointerType.HalfFloat;
+
+                case VertexElementFormat.HalfVector4:
+                    return ColorPointerType.HalfFloat;
+#endif
+			}
+
+            throw new ArgumentException();
+        }
+
+       public static NormalPointerType OpenGLNormalPointerType(this VertexElementFormat elementFormat)
+        {
+            switch (elementFormat)
+            {
+                case VertexElementFormat.Single:
+                    return NormalPointerType.Float;
+
+                case VertexElementFormat.Vector2:
+                    return NormalPointerType.Float;
+
+                case VertexElementFormat.Vector3:
+                    return NormalPointerType.Float;
+
+                case VertexElementFormat.Vector4:
+                    return NormalPointerType.Float;
+
+                case VertexElementFormat.Color:
+                    return NormalPointerType.Byte;
+
+                case VertexElementFormat.Byte4:
+                    return NormalPointerType.Byte;
+
+                case VertexElementFormat.Short2:
+                    return NormalPointerType.Short;
+
+                case VertexElementFormat.Short4:
+                    return NormalPointerType.Short;
+
+                case VertexElementFormat.NormalizedShort2:
+                    return NormalPointerType.Short;
+
+                case VertexElementFormat.NormalizedShort4:
+                    return NormalPointerType.Short;
+				
+#if MONOMAC
+                case VertexElementFormat.HalfVector2:
+                    return NormalPointerType.HalfFloat;
+
+                case VertexElementFormat.HalfVector4:
+                    return NormalPointerType.HalfFloat;
+#endif
+			}
+
+            throw new ArgumentException();
+        }
+
+       public static TexCoordPointerType OpenGLTexCoordPointerType(this VertexElementFormat elementFormat)
+        {
+            switch (elementFormat)
+            {
+                case VertexElementFormat.Single:
+                    return TexCoordPointerType.Float;
+
+                case VertexElementFormat.Vector2:
+                    return TexCoordPointerType.Float;
+
+                case VertexElementFormat.Vector3:
+                    return TexCoordPointerType.Float;
+
+                case VertexElementFormat.Vector4:
+                    return TexCoordPointerType.Float;
+
+                case VertexElementFormat.Color:
+                    return TexCoordPointerType.Float;
+
+                case VertexElementFormat.Byte4:
+                    return TexCoordPointerType.Float;
+
+                case VertexElementFormat.Short2:
+                    return TexCoordPointerType.Short;
+
+                case VertexElementFormat.Short4:
+                    return TexCoordPointerType.Short;
+
+                case VertexElementFormat.NormalizedShort2:
+                    return TexCoordPointerType.Short;
+
+                case VertexElementFormat.NormalizedShort4:
+                    return TexCoordPointerType.Short;
+				
+#if MONOMAC
+                case VertexElementFormat.HalfVector2:
+                    return TexCoordPointerType.HalfFloat;
+
+                case VertexElementFormat.HalfVector4:
+                    return TexCoordPointerType.HalfFloat;
+#endif
+			}
+
+            throw new ArgumentException();
+        }
+
+		
+		public static BlendEquationMode GetBlendEquationMode (this BlendFunction function)
+		{
+			switch (function) {
+			case BlendFunction.Add:
+				return BlendEquationMode.FuncAdd;
+#if WINDOWS || DESKTOPGL || IOS
+			case BlendFunction.Max:
+				return BlendEquationMode.Max;
+			case BlendFunction.Min:
+				return BlendEquationMode.Min;
+#endif
+			case BlendFunction.ReverseSubtract:
+				return BlendEquationMode.FuncReverseSubtract;
+			case BlendFunction.Subtract:
+				return BlendEquationMode.FuncSubtract;
+
+			default:
+                throw new ArgumentException();
+			}
+		}
+
+		public static BlendingFactorSrc GetBlendFactorSrc (this Blend blend)
+		{
+			switch (blend) {
+            case Blend.BlendFactor:
+                return BlendingFactorSrc.ConstantColor;
+			case Blend.DestinationAlpha:
+				return BlendingFactorSrc.DstAlpha;
+			case Blend.DestinationColor:
+				return BlendingFactorSrc.DstColor;
+            case Blend.InverseBlendFactor:
+                return BlendingFactorSrc.OneMinusConstantColor;
+			case Blend.InverseDestinationAlpha:
+				return BlendingFactorSrc.OneMinusDstAlpha;
+			case Blend.InverseDestinationColor:
+				return BlendingFactorSrc.OneMinusDstColor;
+			case Blend.InverseSourceAlpha:
+				return BlendingFactorSrc.OneMinusSrcAlpha;
+			case Blend.InverseSourceColor:
+                return BlendingFactorSrc.OneMinusSrcColor;
+			case Blend.One:
+				return BlendingFactorSrc.One;
+			case Blend.SourceAlpha:
+				return BlendingFactorSrc.SrcAlpha;
+			case Blend.SourceAlphaSaturation:
+				return BlendingFactorSrc.SrcAlphaSaturate;
+			case Blend.SourceColor:
+				return BlendingFactorSrc.SrcColor;
+			case Blend.Zero:
+				return BlendingFactorSrc.Zero;
+            default:
+                throw new ArgumentOutOfRangeException("blend", "The specified blend function is not implemented.");
+            }
+
+		}
+
+		public static BlendingFactorDest GetBlendFactorDest (this Blend blend)
+		{
+			switch (blend) {
+            case Blend.BlendFactor:
+                return BlendingFactorDest.ConstantColor;
+            case Blend.DestinationAlpha:
+                return BlendingFactorDest.DstAlpha;
+            case Blend.DestinationColor:
+                return BlendingFactorDest.DstColor;
+            case Blend.InverseBlendFactor:
+                return BlendingFactorDest.OneMinusConstantColor;
+            case Blend.InverseDestinationAlpha:
+				return BlendingFactorDest.OneMinusDstAlpha;
+            case Blend.InverseDestinationColor:
+                return BlendingFactorDest.OneMinusDstColor;
+            case Blend.InverseSourceAlpha:
+                return BlendingFactorDest.OneMinusSrcAlpha;
+			case Blend.InverseSourceColor:
+				return BlendingFactorDest.OneMinusSrcColor;
+			case Blend.One:
+				return BlendingFactorDest.One;
+			case Blend.SourceAlpha:
+				return BlendingFactorDest.SrcAlpha;
+            case Blend.SourceAlphaSaturation:
+                return BlendingFactorDest.SrcAlphaSaturate;
+            case Blend.SourceColor:
+			    return BlendingFactorDest.SrcColor;
+			case Blend.Zero:
+				return BlendingFactorDest.Zero;
+			default:
+				throw new ArgumentOutOfRangeException("blend", "The specified blend function is not implemented.");
+			}
+
+		}
+
+        public static DepthFunction GetDepthFunction(this CompareFunction compare)
+        {
+            switch (compare)
+            {
+                default:
+                case CompareFunction.Always:
+                    return DepthFunction.Always;
+                case CompareFunction.Equal:
+                    return DepthFunction.Equal;
+                case CompareFunction.Greater:
+                    return DepthFunction.Greater;
+                case CompareFunction.GreaterEqual:
+                    return DepthFunction.Gequal;
+                case CompareFunction.Less:
+                    return DepthFunction.Less;
+                case CompareFunction.LessEqual:
+                    return DepthFunction.Lequal;
+                case CompareFunction.Never:
+                    return DepthFunction.Never;
+                case CompareFunction.NotEqual:
+                    return DepthFunction.Notequal;
+            }
+        }
+
+#if WINDOWS || DESKTOPGL || ANGLE
+        /// <summary>
+        /// Convert a <see cref="SurfaceFormat"/> to an OpenTK.Graphics.ColorFormat.
+        /// This is used for setting up the backbuffer format of the OpenGL context.
+        /// </summary>
+        /// <returns>An OpenTK.Graphics.ColorFormat instance.</returns>
+        /// <param name="format">The <see cref="SurfaceFormat"/> to convert.</param>
+        internal static ColorFormat GetColorFormat(this SurfaceFormat format)
+        {
+            switch (format)
+            {
+                case SurfaceFormat.Alpha8:
+                    return new ColorFormat(0, 0, 0, 8);
+                case SurfaceFormat.Bgr565:
+                    return new ColorFormat(5, 6, 5, 0);
+                case SurfaceFormat.Bgra4444:
+                    return new ColorFormat(4, 4, 4, 4);
+                case SurfaceFormat.Bgra5551:
+                    return new ColorFormat(5, 5, 5, 1);
+                case SurfaceFormat.Bgr32:
+                    return new ColorFormat(8, 8, 8, 0);
+                case SurfaceFormat.Bgra32:
+                case SurfaceFormat.Color:
+                case SurfaceFormat.ColorSRgb:
+                    return new ColorFormat(8, 8, 8, 8);
+                case SurfaceFormat.Rgba1010102:
+                    return new ColorFormat(10, 10, 10, 2);
+                default:
+                    // Floating point backbuffers formats could be implemented
+                    // but they are not typically used on the backbuffer. In
+                    // those cases it is better to create a render target instead.
+                    throw new NotSupportedException();
+            }
+        }
+
+        /// <summary>
+        /// Converts <see cref="PresentInterval"/> to OpenGL swap interval.
+        /// </summary>
+        /// <returns>A value according to EXT_swap_control</returns>
+        /// <param name="interval">The <see cref="PresentInterval"/> to convert.</param>
+        internal static int GetSwapInterval(this PresentInterval interval)
+        {
+            // See http://www.opengl.org/registry/specs/EXT/swap_control.txt
+            // and https://www.opengl.org/registry/specs/EXT/glx_swap_control_tear.txt
+            // OpenTK checks for EXT_swap_control_tear:
+            // if supported, a swap interval of -1 enables adaptive vsync;
+            // otherwise -1 is converted to 1 (vsync enabled.)
+
+            switch (interval)
+            {
+
+                case PresentInterval.Immediate:
+                    return 0;
+                case PresentInterval.One:
+                    return 1;
+                case PresentInterval.Two:
+                    return 2;
+                case PresentInterval.Default:
+                default:
+                    return -1;
+            }
+        }
+#endif
+
+        const SurfaceFormat InvalidFormat = (SurfaceFormat)int.MaxValue;
+		internal static void GetGLFormat (this SurfaceFormat format,
+            GraphicsDevice graphicsDevice,
+            out PixelInternalFormat glInternalFormat,
+            out PixelFormat glFormat,
+            out PixelType glType)
+		{
+			glInternalFormat = PixelInternalFormat.Rgba;
+			glFormat = PixelFormat.Rgba;
+			glType = PixelType.UnsignedByte;
+
+		    var supportsSRgb = graphicsDevice.GraphicsCapabilities.SupportsSRgb;
+            var supportsS3tc = graphicsDevice.GraphicsCapabilities.SupportsS3tc;
+            var supportsPvrtc = graphicsDevice.GraphicsCapabilities.SupportsPvrtc;
+            var supportsEtc1 = graphicsDevice.GraphicsCapabilities.SupportsEtc1;
+            var supportsAtitc = graphicsDevice.GraphicsCapabilities.SupportsAtitc;
+            var supportsFloat = graphicsDevice.GraphicsCapabilities.SupportsFloatTextures;
+            var supportsHalfFloat = graphicsDevice.GraphicsCapabilities.SupportsHalfFloatTextures;
+            var supportsNormalized = graphicsDevice.GraphicsCapabilities.SupportsNormalized;
+            var isGLES2 = GL.BoundApi == GL.RenderApi.ES && graphicsDevice.glMajorVersion == 2;
+
+			switch (format) {
+			case SurfaceFormat.Color:
+				glInternalFormat = PixelInternalFormat.Rgba;
+				glFormat = PixelFormat.Rgba;
+				glType = PixelType.UnsignedByte;
+				break;
+            case SurfaceFormat.ColorSRgb:
+                if (!supportsSRgb)
+                    goto case SurfaceFormat.Color;
+                glInternalFormat = PixelInternalFormat.Srgb;
+                glFormat = PixelFormat.Rgba;
+                glType = PixelType.UnsignedByte;
+                break;
+			case SurfaceFormat.Bgr565:
+				glInternalFormat = PixelInternalFormat.Rgb;
+				glFormat = PixelFormat.Rgb;
+				glType = PixelType.UnsignedShort565;
+				break;
+			case SurfaceFormat.Bgra4444:
+#if IOS || ANDROID
+				glInternalFormat = PixelInternalFormat.Rgba;
+#else
+				glInternalFormat = PixelInternalFormat.Rgba4;
+#endif
+				glFormat = PixelFormat.Rgba;
+				glType = PixelType.UnsignedShort4444;
+				break;
+			case SurfaceFormat.Bgra5551:
+				glInternalFormat = PixelInternalFormat.Rgba;
+				glFormat = PixelFormat.Rgba;
+				glType = PixelType.UnsignedShort5551;
+				break;
+			case SurfaceFormat.Alpha8:
+				glInternalFormat = PixelInternalFormat.Luminance;
+				glFormat = PixelFormat.Luminance;
+				glType = PixelType.UnsignedByte;
+				break;
+			case SurfaceFormat.Dxt1:
+                if (!supportsS3tc)
+                    goto case InvalidFormat;
+				glInternalFormat = PixelInternalFormat.CompressedRgbS3tcDxt1Ext;
+                glFormat = (PixelFormat)GLPixelFormat.CompressedTextureFormats;
+				break;
+            case SurfaceFormat.Dxt1SRgb:
+                if (!supportsSRgb)
+                    goto case SurfaceFormat.Dxt1;
+                glInternalFormat = PixelInternalFormat.CompressedSrgbS3tcDxt1Ext;
+                glFormat = (PixelFormat)GLPixelFormat.CompressedTextureFormats;
+                break;
+            case SurfaceFormat.Dxt1a:
+                if (!supportsS3tc)
+                    goto case InvalidFormat;
+                glInternalFormat = PixelInternalFormat.CompressedRgbaS3tcDxt1Ext;
+                glFormat = (PixelFormat)GLPixelFormat.CompressedTextureFormats;
+                break;
+            case SurfaceFormat.Dxt3:
+                if (!supportsS3tc)
+                    goto case InvalidFormat;
+				glInternalFormat = PixelInternalFormat.CompressedRgbaS3tcDxt3Ext;
+                glFormat = (PixelFormat)GLPixelFormat.CompressedTextureFormats;
+				break;
+            case SurfaceFormat.Dxt3SRgb:
+                if (!supportsSRgb)
+                    goto case SurfaceFormat.Dxt3;
+                glInternalFormat = PixelInternalFormat.CompressedSrgbAlphaS3tcDxt3Ext;
+                glFormat = (PixelFormat)GLPixelFormat.CompressedTextureFormats;
+                break;
+			case SurfaceFormat.Dxt5:
+                if (!supportsS3tc)
+                    goto case InvalidFormat;
+				glInternalFormat = PixelInternalFormat.CompressedRgbaS3tcDxt5Ext;
+                glFormat = (PixelFormat)GLPixelFormat.CompressedTextureFormats;
+				break;
+            case SurfaceFormat.Dxt5SRgb:
+                if (!supportsSRgb)
+                    goto case SurfaceFormat.Dxt5;
+                glInternalFormat = PixelInternalFormat.CompressedSrgbAlphaS3tcDxt5Ext;
+                glFormat = (PixelFormat)GLPixelFormat.CompressedTextureFormats;
+                break;
+#if !IOS && !ANDROID && !ANGLE
+            case SurfaceFormat.Rgba1010102:
+                glInternalFormat = PixelInternalFormat.Rgb10A2ui;
+                glFormat = PixelFormat.Rgba;
+                glType = PixelType.UnsignedInt1010102;
+                break;
+#endif
+            case SurfaceFormat.Single:
+                if (!supportsFloat)
+                    goto case InvalidFormat;
+                glInternalFormat = PixelInternalFormat.R32f;
+                glFormat = PixelFormat.Red;
+                glType = PixelType.Float;
+                break;
+
+            case SurfaceFormat.HalfVector2:
+                if (!supportsHalfFloat)
+                    goto case InvalidFormat;
+                glInternalFormat = PixelInternalFormat.Rg16f;
+				glFormat = PixelFormat.Rg;
+				glType = PixelType.HalfFloat;
+                break;
+
+            // HdrBlendable implemented as HalfVector4 (see http://blogs.msdn.com/b/shawnhar/archive/2010/07/09/surfaceformat-hdrblendable.aspx)
+            case SurfaceFormat.HdrBlendable:
+            case SurfaceFormat.HalfVector4:
+                if (!supportsHalfFloat)
+                    goto case InvalidFormat;
+                glInternalFormat = PixelInternalFormat.Rgba16f;
+                glFormat = PixelFormat.Rgba;
+                glType = PixelType.HalfFloat;
+                break;
+
+            case SurfaceFormat.HalfSingle:
+                if (!supportsHalfFloat)
+                    goto case InvalidFormat;
+                glInternalFormat = PixelInternalFormat.R16f;
+                glFormat = PixelFormat.Red;
+                glType = isGLES2 ? PixelType.HalfFloatOES : PixelType.HalfFloat;
+                break;
+
+            case SurfaceFormat.Vector2:
+                if (!supportsFloat)
+                    goto case InvalidFormat;
+                glInternalFormat = PixelInternalFormat.Rg32f;
+                glFormat = PixelFormat.Rg;
+                glType = PixelType.Float;
+                break;
+
+            case SurfaceFormat.Vector4:
+                if (!supportsFloat)
+                    goto case InvalidFormat;
+                glInternalFormat = PixelInternalFormat.Rgba32f;
+                glFormat = PixelFormat.Rgba;
+                glType = PixelType.Float;
+                break;
+
+            case SurfaceFormat.NormalizedByte2:
+                glInternalFormat = PixelInternalFormat.Rg8i;
+                glFormat = PixelFormat.Rg;
+                glType = PixelType.Byte;
+                break;
+
+            case SurfaceFormat.NormalizedByte4:
+                glInternalFormat = PixelInternalFormat.Rgba8i;
+                glFormat = PixelFormat.Rgba;
+                glType = PixelType.Byte;
+                break;
+
+            case SurfaceFormat.Rg32:
+                if (!supportsNormalized)
+                    goto case InvalidFormat;
+                glInternalFormat = PixelInternalFormat.Rg16ui;
+                glFormat = PixelFormat.Rg;
+                glType = PixelType.UnsignedShort;
+                break;
+
+            case SurfaceFormat.Rgba64:
+                if (!supportsNormalized)
+                    goto case InvalidFormat;
+                glInternalFormat = PixelInternalFormat.Rgba16;
+                glFormat = PixelFormat.Rgba;
+                glType = PixelType.UnsignedShort;
+                break;
+            case SurfaceFormat.RgbaAtcExplicitAlpha:
+                if (!supportsAtitc)
+                    goto case InvalidFormat;
+				glInternalFormat = PixelInternalFormat.AtcRgbaExplicitAlphaAmd;
+				glFormat = PixelFormat.CompressedTextureFormats;
+				break;
+            case SurfaceFormat.RgbaAtcInterpolatedAlpha:
+                if (!supportsAtitc)
+                    goto case InvalidFormat;
+				glInternalFormat = PixelInternalFormat.AtcRgbaInterpolatedAlphaAmd;
+				glFormat = PixelFormat.CompressedTextureFormats;
+				break;
+            case SurfaceFormat.RgbEtc1:
+                if (!supportsEtc1)
+                    goto case InvalidFormat;
+                glInternalFormat = PixelInternalFormat.Etc1; // GL_ETC1_RGB8_OES
+                glFormat = PixelFormat.CompressedTextureFormats;
+                break;
+			case SurfaceFormat.RgbPvrtc2Bpp:
+                if (!supportsPvrtc)
+                    goto case InvalidFormat;
+				glInternalFormat = PixelInternalFormat.CompressedRgbPvrtc2Bppv1Img;
+				glFormat = PixelFormat.CompressedTextureFormats;
+				break;
+			case SurfaceFormat.RgbPvrtc4Bpp:
+                if (!supportsPvrtc)
+                    goto case InvalidFormat;
+				glInternalFormat = PixelInternalFormat.CompressedRgbPvrtc4Bppv1Img;
+				glFormat = PixelFormat.CompressedTextureFormats;
+				break;
+			case SurfaceFormat.RgbaPvrtc2Bpp:
+                if (!supportsPvrtc)
+                    goto case InvalidFormat;
+				glInternalFormat = PixelInternalFormat.CompressedRgbaPvrtc2Bppv1Img;
+				glFormat = PixelFormat.CompressedTextureFormats;
+				break;
+			case SurfaceFormat.RgbaPvrtc4Bpp:
+                if (!supportsPvrtc)
+                    goto case InvalidFormat;
+				glInternalFormat = PixelInternalFormat.CompressedRgbaPvrtc4Bppv1Img;
+				glFormat = PixelFormat.CompressedTextureFormats;
+				break;
+            case InvalidFormat: 
+            default:
+                    throw new NotSupportedException(string.Format("The requested SurfaceFormat `{0}` is not supported.", format));
+			}
+		}
+
+#endif // OPENGL
+
+                    public static int GetSyncInterval(this PresentInterval interval)
+        {
+            switch (interval)
+            {
+                case PresentInterval.Immediate:
+                    return 0;
+
+                case PresentInterval.Two:
+                    return 2;
+
+                default:
+                    return 1;
+            }
+        }
+
+        public static bool IsCompressedFormat(this SurfaceFormat format)
+        {
+            switch (format)
+            {
+                case SurfaceFormat.Dxt1:
+                case SurfaceFormat.Dxt1a:
+                case SurfaceFormat.Dxt1SRgb:
+                case SurfaceFormat.Dxt3:
+                case SurfaceFormat.Dxt3SRgb:
+                case SurfaceFormat.Dxt5:
+                case SurfaceFormat.Dxt5SRgb:
+                case SurfaceFormat.RgbaAtcExplicitAlpha:
+                case SurfaceFormat.RgbaAtcInterpolatedAlpha:
+                case SurfaceFormat.RgbaPvrtc2Bpp:
+                case SurfaceFormat.RgbaPvrtc4Bpp:
+                case SurfaceFormat.RgbEtc1:
+                case SurfaceFormat.RgbPvrtc2Bpp:
+                case SurfaceFormat.RgbPvrtc4Bpp:
+                    return true;
+            }
+            return false;
+        }
+
+        public static int GetSize(this SurfaceFormat surfaceFormat)
+        {
+            switch (surfaceFormat)
+            {
+                case SurfaceFormat.Dxt1:
+                case SurfaceFormat.Dxt1SRgb:
+                case SurfaceFormat.Dxt1a:
+                case SurfaceFormat.RgbPvrtc2Bpp:
+                case SurfaceFormat.RgbaPvrtc2Bpp:
+                case SurfaceFormat.RgbPvrtc4Bpp:
+                case SurfaceFormat.RgbaPvrtc4Bpp:
+                case SurfaceFormat.RgbEtc1:
+                    // One texel in DXT1, PVRTC (2bpp and 4bpp) and ETC1 is a minimum 4x4 block (8x4 for PVRTC 2bpp), which is 8 bytes
+                    return 8;
+                case SurfaceFormat.Dxt3:
+                case SurfaceFormat.Dxt3SRgb:
+                case SurfaceFormat.Dxt5:
+                case SurfaceFormat.Dxt5SRgb:
+                case SurfaceFormat.RgbaAtcExplicitAlpha:
+                case SurfaceFormat.RgbaAtcInterpolatedAlpha:
+                    // One texel in DXT3 and DXT5 is a minimum 4x4 block, which is 16 bytes
+                    return 16;
+                case SurfaceFormat.Alpha8:
+                    return 1;
+                case SurfaceFormat.Bgr565:
+                case SurfaceFormat.Bgra4444:
+                case SurfaceFormat.Bgra5551:
+                case SurfaceFormat.HalfSingle:
+                case SurfaceFormat.NormalizedByte2:
+                    return 2;
+                case SurfaceFormat.Color:
+                case SurfaceFormat.ColorSRgb:
+                case SurfaceFormat.Single:
+                case SurfaceFormat.Rg32:
+                case SurfaceFormat.HalfVector2:
+                case SurfaceFormat.NormalizedByte4:
+                case SurfaceFormat.Rgba1010102:
+                case SurfaceFormat.Bgra32:
+                case SurfaceFormat.Bgra32SRgb:
+                case SurfaceFormat.Bgr32:
+                case SurfaceFormat.Bgr32SRgb:
+                    return 4;
+                case SurfaceFormat.HalfVector4:
+                case SurfaceFormat.Rgba64:
+                case SurfaceFormat.Vector2:
+                    return 8;
+                case SurfaceFormat.Vector4:
+                    return 16;
+                default:
+                    throw new ArgumentException();
+            }
+        }
+
+        public static int GetSize(this VertexElementFormat elementFormat)
+        {
+            switch (elementFormat)
+            {
+                case VertexElementFormat.Single:
+                    return 4;
+
+                case VertexElementFormat.Vector2:
+                    return 8;
+
+                case VertexElementFormat.Vector3:
+                    return 12;
+
+                case VertexElementFormat.Vector4:
+                    return 16;
+
+                case VertexElementFormat.Color:
+                    return 4;
+
+                case VertexElementFormat.Byte4:
+                    return 4;
+
+                case VertexElementFormat.Short2:
+                    return 4;
+
+                case VertexElementFormat.Short4:
+                    return 8;
+
+                case VertexElementFormat.NormalizedShort2:
+                    return 4;
+
+                case VertexElementFormat.NormalizedShort4:
+                    return 8;
+
+                case VertexElementFormat.HalfVector2:
+                    return 4;
+
+                case VertexElementFormat.HalfVector4:
+                    return 8;
+            }
+            return 0;
+        }
+
+        public static void GetBlockSize(this SurfaceFormat surfaceFormat, out int width, out int height)
+        {
+            switch (surfaceFormat)
+            {
+                case SurfaceFormat.RgbPvrtc2Bpp:
+                case SurfaceFormat.RgbaPvrtc2Bpp:
+                    width = 8;
+                    height = 4;
+                    break;
+                case SurfaceFormat.Dxt1:
+                case SurfaceFormat.Dxt1SRgb:
+                case SurfaceFormat.Dxt1a:
+                case SurfaceFormat.Dxt3:
+                case SurfaceFormat.Dxt3SRgb:
+                case SurfaceFormat.Dxt5:
+                case SurfaceFormat.Dxt5SRgb:
+                case SurfaceFormat.RgbPvrtc4Bpp:
+                case SurfaceFormat.RgbaPvrtc4Bpp:
+                case SurfaceFormat.RgbEtc1:
+                case SurfaceFormat.RgbaAtcExplicitAlpha:
+                case SurfaceFormat.RgbaAtcInterpolatedAlpha:
+                    width = 4;
+                    height = 4;
+                    break;
+                default:
+                    width = 1;
+                    height = 1;
+                    break;
+            }
+        }
+
+#if OPENGL
+
+        public static int GetBoundTexture2D()
+        {
+            var prevTexture = 0;
+            GL.GetInteger(GetPName.TextureBinding2D, out prevTexture);
+            GraphicsExtensions.LogGLError("GraphicsExtensions.GetBoundTexture2D() GL.GetInteger");
+            return prevTexture;
+        }
+
+        [Conditional("DEBUG")]
+		[DebuggerHidden]
+        public static void CheckGLError()
+        {
+           var error = GL.GetError();
+            //Console.WriteLine(error);
+            if (error != ErrorCode.NoError)
+                throw new MonoGameGLException("GL.GetError() returned " + error.ToString());
+        }
+#endif
+
+#if OPENGL
+        [Conditional("DEBUG")]
+        public static void LogGLError(string location)
+        {
+            try
+            {
+                GraphicsExtensions.CheckGLError();
+            }
+            catch (MonoGameGLException ex)
+            {
+#if ANDROID
+                // Todo: Add generic MonoGame logging interface
+                Android.Util.Log.Debug("MonoGame", "MonoGameGLException at " + location + " - " + ex.Message);
+#else
+                Debug.WriteLine("MonoGameGLException at " + location + " - " + ex.Message);
+#endif
+            }
+        }
+#endif
+            }
+
+    internal class MonoGameGLException : Exception
+    {
+        public MonoGameGLException(string message)
+            : base(message)
+        {
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsMetrics.cs b/MonoGame.Framework/Graphics/GraphicsMetrics.cs
new file mode 100644
index 00000000000..feb30f34ef3
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsMetrics.cs
@@ -0,0 +1,103 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// A snapshot of rendering statistics from <see cref="GraphicsDevice.Metrics"/> to be used for runtime debugging and profiling.
+    /// </summary>
+    public struct GraphicsMetrics
+    {
+        internal long _clearCount;
+        internal long _drawCount;
+        internal long _pixelShaderCount;
+        internal long _primitiveCount;
+        internal long _spriteCount;
+        internal long _targetCount;
+        internal long _textureCount;
+        internal long _vertexShaderCount;
+
+        /// <summary>
+        /// Number of times Clear was called.
+        /// </summary>
+        public long ClearCount { get { return _clearCount; } }
+
+        /// <summary>
+        /// Number of times Draw was called.
+        /// </summary>
+        public long DrawCount { get { return _drawCount; } }
+
+        /// <summary>
+        /// Number of times the pixel shader was changed on the GPU.
+        /// </summary>
+        public long PixelShaderCount { get { return _pixelShaderCount; } }
+
+        /// <summary>
+        /// Number of rendered primitives.
+        /// </summary>
+        public long PrimitiveCount { get { return _primitiveCount; } }
+
+        /// <summary>
+        /// Number of sprites and text characters rendered via <see cref="SpriteBatch"/>.
+        /// </summary>
+        public long SpriteCount { get { return _spriteCount; } }
+
+        /// <summary>
+        /// Number of times a target was changed on the GPU.
+        /// </summary>
+        public long TargetCount {get { return _targetCount; } }
+
+        /// <summary>
+        /// Number of times a texture was changed on the GPU.
+        /// </summary>
+        public long TextureCount { get { return _textureCount; } }
+
+        /// <summary>
+        /// Number of times the vertex shader was changed on the GPU.
+        /// </summary>
+        public long VertexShaderCount { get { return _vertexShaderCount; } }
+
+        /// <summary>
+        /// Returns the difference between two sets of metrics.
+        /// </summary>
+        /// <param name="value1">Source <see cref="GraphicsMetrics"/> on the left of the sub sign.</param>
+        /// <param name="value2">Source <see cref="GraphicsMetrics"/> on the right of the sub sign.</param>
+        /// <returns>Difference between two sets of metrics.</returns>
+        public static GraphicsMetrics operator -(GraphicsMetrics value1, GraphicsMetrics value2)
+        {
+            return new GraphicsMetrics()
+            {
+                _clearCount = value1._clearCount - value2._clearCount,
+                _drawCount = value1._drawCount - value2._drawCount,
+                _pixelShaderCount = value1._pixelShaderCount - value2._pixelShaderCount,
+                _primitiveCount = value1._primitiveCount - value2._primitiveCount,
+                _spriteCount = value1._spriteCount - value2._spriteCount,
+                _targetCount = value1._targetCount - value2._targetCount,
+                _textureCount = value1._textureCount - value2._textureCount,
+                _vertexShaderCount = value1._vertexShaderCount - value2._vertexShaderCount
+            };
+        }
+
+        /// <summary>
+        /// Returns the combination of two sets of metrics.
+        /// </summary>
+        /// <param name="value1">Source <see cref="GraphicsMetrics"/> on the left of the add sign.</param>
+        /// <param name="value2">Source <see cref="GraphicsMetrics"/> on the right of the add sign.</param>
+        /// <returns>Combination of two sets of metrics.</returns>
+        public static GraphicsMetrics operator +(GraphicsMetrics value1, GraphicsMetrics value2)
+        {
+            return new GraphicsMetrics()
+            {
+                _clearCount =  value1._clearCount + value2._clearCount,
+                _drawCount = value1._drawCount + value2._drawCount,
+                _pixelShaderCount = value1._pixelShaderCount + value2._pixelShaderCount,
+                _primitiveCount = value1._primitiveCount + value2._primitiveCount,
+                _spriteCount = value1._spriteCount + value2._spriteCount,
+                _targetCount = value1._targetCount + value2._targetCount,
+                _textureCount = value1._textureCount + value2._textureCount,
+                _vertexShaderCount = value1._vertexShaderCount + value2._vertexShaderCount
+            };
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsProfile.cs b/MonoGame.Framework/Graphics/GraphicsProfile.cs
new file mode 100644
index 00000000000..02e421f23a2
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsProfile.cs
@@ -0,0 +1,21 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines a set of graphic capabilities.
+    /// </summary>
+	public enum GraphicsProfile
+	{
+        /// <summary>
+        /// Use a limited set of graphic features and capabilities, allowing the game to support the widest variety of devices.
+        /// </summary>
+        Reach,
+        /// <summary>
+        /// Use the largest available set of graphic features and capabilities to target devices, that have more enhanced graphic capabilities.        
+        /// </summary>
+        HiDef
+	}
+}
diff --git a/MonoGame.Framework/Graphics/GraphicsResource.cs b/MonoGame.Framework/Graphics/GraphicsResource.cs
new file mode 100644
index 00000000000..6c08c29791f
--- /dev/null
+++ b/MonoGame.Framework/Graphics/GraphicsResource.cs
@@ -0,0 +1,168 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+using System;
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public abstract class GraphicsResource : IDisposable
+    {
+        bool disposed;
+
+        // The GraphicsDevice property should only be accessed in Dispose(bool) if the disposing
+        // parameter is true. If disposing is false, the GraphicsDevice may or may not be
+        // disposed yet.
+        GraphicsDevice graphicsDevice;
+
+        private WeakReference _selfReference;
+
+        internal GraphicsResource()
+        {
+            
+        }
+
+        ~GraphicsResource()
+        {
+            // Pass false so the managed objects are not released
+            Dispose(false);
+        }
+
+        /// <summary>
+        /// Called before the device is reset. Allows graphics resources to 
+        /// invalidate their state so they can be recreated after the device reset.
+        /// Warning: This may be called after a call to Dispose() up until
+        /// the resource is garbage collected.
+        /// </summary>
+        internal protected virtual void GraphicsDeviceResetting()
+        {
+
+        }
+
+        public void Dispose()
+        {
+            // Dispose of managed objects as well
+            Dispose(true);
+            // Since we have been manually disposed, do not call the finalizer on this object
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// The method that derived classes should override to implement disposing of managed and native resources.
+        /// </summary>
+        /// <param name="disposing">True if managed objects should be disposed.</param>
+        /// <remarks>Native resources should always be released regardless of the value of the disposing parameter.</remarks>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposed)
+            {
+                if (disposing)
+                {
+                    // Release managed objects
+                    // ...
+                }
+
+                // Release native objects
+                // ...
+
+                // Do not trigger the event if called from the finalizer
+                if (disposing)
+                    EventHelpers.Raise(this, Disposing, EventArgs.Empty);
+
+                // Remove from the global list of graphics resources
+                if (graphicsDevice != null)
+                    graphicsDevice.RemoveResourceReference(_selfReference);
+
+                _selfReference = null;
+                graphicsDevice = null;
+                disposed = true;
+            }
+        }
+
+		public event EventHandler<EventArgs> Disposing;
+		
+		public GraphicsDevice GraphicsDevice
+		{
+			get
+			{
+				return graphicsDevice;
+			}
+
+            internal set
+            {
+                Debug.Assert(value != null);
+
+                if (graphicsDevice == value)
+                    return;
+
+                // VertexDeclaration objects can be bound to multiple GraphicsDevice objects
+                // during their lifetime. But only one GraphicsDevice should retain ownership.
+                if (graphicsDevice != null)
+                {
+                    graphicsDevice.RemoveResourceReference(_selfReference);
+                    _selfReference = null;
+                }
+
+                graphicsDevice = value;
+
+                _selfReference = new WeakReference(this);
+                graphicsDevice.AddResourceReference(_selfReference);
+            }
+		}
+		
+		public bool IsDisposed
+		{
+			get
+			{
+				return disposed;
+			}
+		}
+		
+		public string Name { get; set; }
+		
+		public Object Tag { get; set; }
+
+        public override string ToString()
+        {
+            return string.IsNullOrEmpty(Name) ? base.ToString() : Name;
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/IGraphicsContext.cs b/MonoGame.Framework/Graphics/IGraphicsContext.cs
new file mode 100644
index 00000000000..53d4af2070a
--- /dev/null
+++ b/MonoGame.Framework/Graphics/IGraphicsContext.cs
@@ -0,0 +1,17 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace MonoGame.OpenGL
+{
+    internal interface IGraphicsContext : IDisposable
+    {
+        int SwapInterval { get; set; }
+        bool IsDisposed { get; }
+        void MakeCurrent(IWindowInfo info);
+        void SwapBuffers();
+        bool IsCurrent { get; }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/IGraphicsDeviceService.cs b/MonoGame.Framework/Graphics/IGraphicsDeviceService.cs
new file mode 100644
index 00000000000..57221a60854
--- /dev/null
+++ b/MonoGame.Framework/Graphics/IGraphicsDeviceService.cs
@@ -0,0 +1,55 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public interface IGraphicsDeviceService
+    {
+		Microsoft.Xna.Framework.Graphics.GraphicsDevice GraphicsDevice { get; }
+        
+		event EventHandler<EventArgs> DeviceCreated;
+        event EventHandler<EventArgs> DeviceDisposing;
+        event EventHandler<EventArgs> DeviceReset;
+        event EventHandler<EventArgs> DeviceResetting;
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/IRenderTarget.cs b/MonoGame.Framework/Graphics/IRenderTarget.cs
new file mode 100644
index 00000000000..ee8d6da8e6f
--- /dev/null
+++ b/MonoGame.Framework/Graphics/IRenderTarget.cs
@@ -0,0 +1,102 @@
+#region License
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+#endregion License
+
+#if DIRECTX
+using SharpDX.Direct3D11;
+#endif
+
+#if OPENGL
+using MonoGame.OpenGL;
+#endif
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Represents a render target.
+    /// </summary>
+    internal interface IRenderTarget
+    {
+        /// <summary>
+        /// Gets the width of the render target in pixels
+        /// </summary>
+        /// <value>The width of the render target in pixels.</value>
+        int Width { get; }
+
+        /// <summary>
+        /// Gets the height of the render target in pixels
+        /// </summary>
+        /// <value>The height of the render target in pixels.</value>
+        int Height { get; }
+
+        /// <summary>
+        /// Gets the usage mode of the render target.
+        /// </summary>
+        /// <value>The usage mode of the render target.</value>
+        RenderTargetUsage RenderTargetUsage { get; }
+
+#if DIRECTX
+        /// <summary>
+        /// Gets the <see cref="RenderTargetView"/> for the specified array slice.
+        /// </summary>
+        /// <param name="arraySlice">The array slice.</param>
+        /// <returns>The <see cref="RenderTargetView"/>.</returns>
+        /// <remarks>
+        /// For texture cubes: The array slice is the index of the cube map face.
+        /// </remarks>
+        RenderTargetView GetRenderTargetView(int arraySlice);
+
+        /// <summary>
+        /// Gets the <see cref="DepthStencilView"/>.
+        /// </summary>
+        /// <returns>The <see cref="DepthStencilView"/>. Can be <see langword="null"/>.</returns>
+        DepthStencilView GetDepthStencilView();
+#endif
+
+#if OPENGL
+        int GLTexture { get; }
+        TextureTarget GLTarget { get; }
+        int GLColorBuffer { get; set; }
+        int GLDepthBuffer { get; set; }
+        int GLStencilBuffer { get; set; }
+        int MultiSampleCount { get; }
+        int LevelCount { get; }
+
+        TextureTarget GetFramebufferTarget(RenderTargetBinding renderTargetBinding);
+#endif
+    }
+}
diff --git a/MonoGame.Framework/Graphics/IWindowInfo.cs b/MonoGame.Framework/Graphics/IWindowInfo.cs
new file mode 100644
index 00000000000..0efc39ade83
--- /dev/null
+++ b/MonoGame.Framework/Graphics/IWindowInfo.cs
@@ -0,0 +1,13 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace MonoGame.OpenGL
+{
+    public interface IWindowInfo
+    {
+        IntPtr Handle { get; }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Model.cs b/MonoGame.Framework/Graphics/Model.cs
new file mode 100644
index 00000000000..e42186185cd
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Model.cs
@@ -0,0 +1,219 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// A basic 3D model with per mesh parent bones.
+    /// </summary>
+	public sealed class Model
+	{
+		private static Matrix[] sharedDrawBoneMatrices;
+		
+		private GraphicsDevice graphicsDevice;
+
+        /// <summary>
+        /// A collection of <see cref="ModelBone"/> objects which describe how each mesh in the
+        /// mesh collection for this model relates to its parent mesh.
+        /// </summary>
+        public ModelBoneCollection Bones { get; private set; }
+
+        /// <summary>
+        /// A collection of <see cref="ModelMesh"/> objects which compose the model. Each <see cref="ModelMesh"/>
+        /// in a model may be moved independently and may be composed of multiple materials
+        /// identified as <see cref="ModelMeshPart"/> objects.
+        /// </summary>
+        public ModelMeshCollection Meshes { get; private set; }
+
+        /// <summary>
+        /// Root bone for this model.
+        /// </summary>
+        public ModelBone Root { get; set; }
+
+        /// <summary>
+        /// Custom attached object.
+        /// <remarks>
+        /// Skinning data is example of attached object for model.
+        /// </remarks>
+        /// </summary>
+        public object Tag { get; set; }
+
+		internal Model()
+		{
+
+		}
+
+        /// <summary>
+        /// Constructs a model. 
+        /// </summary>
+        /// <param name="graphicsDevice">A valid reference to <see cref="GraphicsDevice"/>.</param>
+        /// <param name="bones">The collection of bones.</param>
+        /// <param name="meshes">The collection of meshes.</param>
+        /// <exception cref="ArgumentNullException">
+        /// <paramref name="graphicsDevice"/> is null.
+        /// </exception>
+        /// <exception cref="ArgumentNullException">
+        /// <paramref name="bones"/> is null.
+        /// </exception>
+        /// <exception cref="ArgumentNullException">
+        /// <paramref name="meshes"/> is null.
+        /// </exception>
+        public Model(GraphicsDevice graphicsDevice, List<ModelBone> bones, List<ModelMesh> meshes)
+		{
+            if (graphicsDevice == null)
+            {
+                throw new ArgumentNullException("graphicsDevice", FrameworkResources.ResourceCreationWhenDeviceIsNull);
+            }
+
+			// TODO: Complete member initialization
+			this.graphicsDevice = graphicsDevice;
+
+			Bones = new ModelBoneCollection(bones);
+			Meshes = new ModelMeshCollection(meshes);
+		}
+
+        internal void BuildHierarchy()
+		{
+			var globalScale = Matrix.CreateScale(0.01f);
+			
+			foreach(var node in this.Root.Children)
+			{
+				BuildHierarchy(node, this.Root.Transform * globalScale, 0);
+			}
+		}
+		
+		private void BuildHierarchy(ModelBone node, Matrix parentTransform, int level)
+		{
+			node.ModelTransform = node.Transform * parentTransform;
+			
+			foreach (var child in node.Children) 
+			{
+				BuildHierarchy(child, node.ModelTransform, level + 1);
+			}
+			
+			//string s = string.Empty;
+			//
+			//for (int i = 0; i < level; i++) 
+			//{
+			//	s += "\t";
+			//}
+			//
+			//Debug.WriteLine("{0}:{1}", s, node.Name);
+		}
+
+        /// <summary>
+        /// Draws the model meshes.
+        /// </summary>
+        /// <param name="world">The world transform.</param>
+        /// <param name="view">The view transform.</param>
+        /// <param name="projection">The projection transform.</param>
+        public void Draw(Matrix world, Matrix view, Matrix projection) 
+		{       
+            int boneCount = this.Bones.Count;
+			
+			if (sharedDrawBoneMatrices == null ||
+				sharedDrawBoneMatrices.Length < boneCount)
+			{
+				sharedDrawBoneMatrices = new Matrix[boneCount];    
+			}
+			
+			// Look up combined bone matrices for the entire model.            
+			CopyAbsoluteBoneTransformsTo(sharedDrawBoneMatrices);
+
+            // Draw the model.
+            foreach (ModelMesh mesh in Meshes)
+            {
+                foreach (Effect effect in mesh.Effects)
+                {
+					IEffectMatrices effectMatricies = effect as IEffectMatrices;
+					if (effectMatricies == null) {
+						throw new InvalidOperationException();
+					}
+                    effectMatricies.World = sharedDrawBoneMatrices[mesh.ParentBone.Index] * world;
+                    effectMatricies.View = view;
+                    effectMatricies.Projection = projection;
+                }
+
+                mesh.Draw();
+            }
+		}
+
+        /// <summary>
+        /// Copies bone transforms relative to all parent bones of the each bone from this model to a given array.
+        /// </summary>
+        /// <param name="destinationBoneTransforms">The array receiving the transformed bones.</param>
+        public void CopyAbsoluteBoneTransformsTo(Matrix[] destinationBoneTransforms)
+		{
+			if (destinationBoneTransforms == null)
+				throw new ArgumentNullException("destinationBoneTransforms");
+            if (destinationBoneTransforms.Length < this.Bones.Count)
+				throw new ArgumentOutOfRangeException("destinationBoneTransforms");
+            int count = this.Bones.Count;
+			for (int index1 = 0; index1 < count; ++index1)
+			{
+                ModelBone modelBone = (this.Bones)[index1];
+				if (modelBone.Parent == null)
+				{
+					destinationBoneTransforms[index1] = modelBone.transform;
+				}
+				else
+				{
+					int index2 = modelBone.Parent.Index;
+					Matrix.Multiply(ref modelBone.transform, ref destinationBoneTransforms[index2], out destinationBoneTransforms[index1]);
+				}
+			}
+		}
+
+        /// <summary>
+        /// Copies bone transforms relative to <see cref="Model.Root"/> bone from a given array to this model.
+        /// </summary>
+        /// <param name="sourceBoneTransforms">The array of prepared bone transform data.</param>
+        /// <exception cref="ArgumentNullException">
+        /// <paramref name="sourceBoneTransforms"/> is null.
+        /// </exception>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// <paramref name="sourceBoneTransforms"/> is invalid.
+        /// </exception>
+        public void CopyBoneTransformsFrom(Matrix[] sourceBoneTransforms)
+        {
+            if (sourceBoneTransforms == null)
+                throw new ArgumentNullException("sourceBoneTransforms");
+            if (sourceBoneTransforms.Length < Bones.Count)
+                throw new ArgumentOutOfRangeException("sourceBoneTransforms");
+
+            int count = Bones.Count;
+            for (int i = 0; i < count; i++)
+            {
+                Bones[i].Transform = sourceBoneTransforms[i];
+            }
+        }
+
+        /// <summary>
+        /// Copies bone transforms relative to <see cref="Model.Root"/> bone from this model to a given array.
+        /// </summary>
+        /// <param name="destinationBoneTransforms">The array receiving the transformed bones.</param>
+        /// <exception cref="ArgumentNullException">
+        /// <paramref name="destinationBoneTransforms"/> is null.
+        /// </exception>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// <paramref name="destinationBoneTransforms"/> is invalid.
+        /// </exception>
+        public void CopyBoneTransformsTo(Matrix[] destinationBoneTransforms)
+        {
+            if (destinationBoneTransforms == null)
+                throw new ArgumentNullException("destinationBoneTransforms");
+            if (destinationBoneTransforms.Length < Bones.Count)
+                throw new ArgumentOutOfRangeException("destinationBoneTransforms");
+
+            int count = Bones.Count;
+            for (int i = 0; i < count; i++)
+            {
+                destinationBoneTransforms[i] = Bones[i].Transform;
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/ModelBone.cs b/MonoGame.Framework/Graphics/ModelBone.cs
new file mode 100644
index 00000000000..61d250f18d6
--- /dev/null
+++ b/MonoGame.Framework/Graphics/ModelBone.cs
@@ -0,0 +1,102 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	// Summary:
+	//     Represents bone data for a model. Reference page contains links to related
+	//     conceptual articles.
+	public sealed class ModelBone
+	{
+		private List<ModelBone> children = new List<ModelBone>();
+		
+		private List<ModelMesh> meshes = new List<ModelMesh>();
+
+		public List<ModelMesh> Meshes {
+			get {
+				return this.meshes;
+			}
+			private set {
+				meshes = value;
+			}
+		}
+
+		// Summary:
+		//     Gets a collection of bones that are children of this bone.
+		public ModelBoneCollection Children { get; private set; }
+		//
+		// Summary:
+		//     Gets the index of this bone in the Bones collection.
+		public int Index { get; set; }
+		//
+		// Summary:
+		//     Gets the name of this bone.
+		public string Name { get; set; }
+		//
+		// Summary:
+		//     Gets the parent of this bone.
+		public ModelBone Parent { get; set; }
+		//
+		// Summary:
+		//     Gets or sets the matrix used to transform this bone relative to its parent
+		//     bone.
+		internal Matrix transform;
+		public Matrix Transform 
+		{ 
+			get { return this.transform; } 
+			set { this.transform = value; }
+		}
+		
+		/// <summary>
+		/// Transform of this node from the root of the model not from the parent
+		/// </summary>
+		public Matrix ModelTransform {
+			get;
+			set;
+		}
+		
+		public ModelBone ()	
+		{
+			Children = new ModelBoneCollection(new List<ModelBone>());
+		}
+		
+		public void AddMesh(ModelMesh mesh)
+		{
+			meshes.Add(mesh);
+		}
+
+		public void AddChild(ModelBone modelBone)
+		{
+			children.Add(modelBone);
+			Children = new ModelBoneCollection(children);
+		}
+	}
+
+	//// Summary:
+	////     Represents bone data for a model. Reference page contains links to related
+	////     conceptual articles.
+	//public sealed class ModelBone
+	//{
+	//    // Summary:
+	//    //     Gets a collection of bones that are children of this bone.
+	//    public ModelBoneCollection Children { get { throw new NotImplementedException(); } }
+	//    //
+	//    // Summary:
+	//    //     Gets the index of this bone in the Bones collection.
+	//    public int Index { get { throw new NotImplementedException(); } }
+	//    //
+	//    // Summary:
+	//    //     Gets the name of this bone.
+	//    public string Name { get { throw new NotImplementedException(); } }
+	//    //
+	//    // Summary:
+	//    //     Gets the parent of this bone.
+	//    public ModelBone Parent { get { throw new NotImplementedException(); } }
+	//    //
+	//    // Summary:
+	//    //     Gets or sets the matrix used to transform this bone relative to its parent
+	//    //     bone.
+	//    public Matrix Transform { get { throw new NotImplementedException(); } set { throw new NotImplementedException(); } }
+	//}
+}
diff --git a/MonoGame.Framework/Graphics/ModelBoneCollection.cs b/MonoGame.Framework/Graphics/ModelBoneCollection.cs
new file mode 100644
index 00000000000..e80b999c83d
--- /dev/null
+++ b/MonoGame.Framework/Graphics/ModelBoneCollection.cs
@@ -0,0 +1,126 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Represents a set of bones associated with a model.
+    /// </summary>
+    public class ModelBoneCollection : ReadOnlyCollection<ModelBone>
+    {
+        public ModelBoneCollection(IList<ModelBone> list)
+            : base(list)
+        {
+
+        }
+
+        /// <summary>
+        /// Retrieves a ModelBone from the collection, given the name of the bone.
+        /// </summary>
+        /// <param name="boneName">The name of the bone to retrieve.</param>
+        public ModelBone this[string boneName]
+        {
+            get
+            {
+                ModelBone ret;
+                if (!TryGetValue(boneName, out ret))
+                    throw new KeyNotFoundException();
+                return ret;
+            }
+        }
+
+        /// <summary>
+        /// Finds a bone with a given name if it exists in the collection.
+        /// </summary>
+        /// <param name="boneName">The name of the bone to find.</param>
+        /// <param name="value">The bone named boneName, if found.</param>
+        /// <returns>true if the bone was found</returns>
+        public bool TryGetValue(string boneName, out ModelBone value)
+        {
+            if (string.IsNullOrEmpty(boneName))
+                throw new ArgumentNullException("boneName");
+
+            foreach (ModelBone bone in this)
+            {
+                if (bone.Name == boneName)
+                {
+                    value = bone;
+                    return true;
+                }
+            }
+
+            value = null;
+            return false;
+        }
+
+        /// <summary>
+        /// Returns a ModelMeshCollection.Enumerator that can iterate through a ModelMeshCollection.
+        /// </summary>
+        /// <returns></returns>
+        public new Enumerator GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        /// <summary>
+        /// Provides the ability to iterate through the bones in an ModelMeshCollection.
+        /// </summary>
+        public struct Enumerator : IEnumerator<ModelBone>
+        {
+            private readonly ModelBoneCollection _collection;
+            private int _position;
+
+            internal Enumerator(ModelBoneCollection collection)
+            {
+                _collection = collection;
+                _position = -1;
+            }
+
+
+            /// <summary>
+            /// Gets the current element in the ModelMeshCollection.
+            /// </summary>
+            public ModelBone Current { get { return _collection[_position]; } }
+
+            /// <summary>
+            /// Advances the enumerator to the next element of the ModelMeshCollection.
+            /// </summary>
+            public bool MoveNext()
+            {
+                _position++;
+                return (_position < _collection.Count);
+            }
+
+            #region IDisposable
+
+            /// <summary>
+            /// Immediately releases the unmanaged resources used by this object.
+            /// </summary>
+            public void Dispose()
+            {
+            }
+
+            #endregion
+
+            #region IEnumerator Members
+
+            object IEnumerator.Current
+            {
+                get { return _collection[_position]; }
+            }
+
+            public void Reset()
+            {
+                _position = -1;
+            }
+
+            #endregion
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/ModelEffectCollection.cs b/MonoGame.Framework/Graphics/ModelEffectCollection.cs
new file mode 100644
index 00000000000..0cd55ca1f6a
--- /dev/null
+++ b/MonoGame.Framework/Graphics/ModelEffectCollection.cs
@@ -0,0 +1,88 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	// Summary:
+	//     Represents a collection of effects associated with a model.
+	public sealed class ModelEffectCollection : ReadOnlyCollection<Effect>
+	{
+		internal ModelEffectCollection(IList<Effect> list)
+			: base(list)
+		{
+
+		}
+
+	    internal ModelEffectCollection() : base(new List<Effect>())
+	    {
+	    }
+		
+		//ModelMeshPart needs to be able to add to ModelMesh's effects list
+		internal void Add(Effect item)
+		{
+			Items.Add (item);
+		}
+		internal void Remove(Effect item)
+		{
+			Items.Remove (item);
+		}
+
+	    // Summary:
+	    //     Returns a ModelEffectCollection.Enumerator that can iterate through a ModelEffectCollection.
+	    public new ModelEffectCollection.Enumerator GetEnumerator()
+		{
+			return new ModelEffectCollection.Enumerator((List<Effect>)Items);
+		}
+
+	    // Summary:
+	    //     Provides the ability to iterate through the bones in an ModelEffectCollection.
+	    public struct Enumerator : IEnumerator<Effect>, IDisposable, IEnumerator
+	    {
+			List<Effect>.Enumerator enumerator;
+            bool disposed;
+
+			internal Enumerator(List<Effect> list)
+			{
+				enumerator = list.GetEnumerator();
+                disposed = false;
+			}
+
+	        // Summary:
+	        //     Gets the current element in the ModelEffectCollection.
+	        public Effect Current { get { return enumerator.Current; } }
+
+	        // Summary:
+	        //     Immediately releases the unmanaged resources used by this object.
+	        public void Dispose()
+            {
+                if (!disposed)
+                {
+                    enumerator.Dispose();
+                    disposed = true;
+                }
+            }
+	        //
+	        // Summary:
+	        //     Advances the enumerator to the next element of the ModelEffectCollection.
+	        public bool MoveNext() { return enumerator.MoveNext(); }
+
+	        #region IEnumerator Members
+
+	        object IEnumerator.Current
+	        {
+	            get { return Current; }
+	        }
+
+	        void IEnumerator.Reset()
+	        {
+				IEnumerator resetEnumerator = enumerator;
+				resetEnumerator.Reset ();
+				enumerator = (List<Effect>.Enumerator)resetEnumerator;
+	        }
+
+	        #endregion
+	    }
+	}
+}
diff --git a/MonoGame.Framework/Graphics/ModelMesh.cs b/MonoGame.Framework/Graphics/ModelMesh.cs
new file mode 100644
index 00000000000..e5426d96e7b
--- /dev/null
+++ b/MonoGame.Framework/Graphics/ModelMesh.cs
@@ -0,0 +1,131 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+
+	// Summary:
+	//     Represents a mesh that is part of a Model.
+	public sealed class ModelMesh
+	{
+		private GraphicsDevice graphicsDevice;
+
+		public ModelMesh(GraphicsDevice graphicsDevice, System.Collections.Generic.List<ModelMeshPart> parts)
+		{
+			// TODO: Complete member initialization
+			this.graphicsDevice = graphicsDevice;
+			
+			MeshParts = new ModelMeshPartCollection(parts);
+			
+			for (int i = 0; i < parts.Count; i++) {
+				parts[i].parent = this;
+			}
+			
+			Effects = new ModelEffectCollection();
+		}
+		
+		/*internal void BuildEffectList()
+		{
+			List<Effect> effects = new List<Effect>();
+			foreach (ModelMeshPart item in parts) 
+			{
+				if (!effects.Contains(item.Effect))
+				{
+					if (item.Effect != null)
+						effects.Add(item.Effect);
+				}
+			}
+			Effects = new ModelEffectCollection(effects);
+		}*/
+		
+		// Summary:
+		//     Gets the BoundingSphere that contains this mesh.
+		public BoundingSphere BoundingSphere { get; set; }
+		//
+		// Summary:
+		//     Gets a collection of effects associated with this mesh.
+		public ModelEffectCollection Effects { get; internal set; }
+		//
+		// Summary:
+		//     Gets the ModelMeshPart objects that make up this mesh. Each part of a mesh
+		//     is composed of a set of primitives that share the same material.
+		public ModelMeshPartCollection MeshParts { get; set; }
+		//
+		// Summary:
+		//     Gets the name of this mesh.
+		public string Name { get; set; }
+		//
+		// Summary:
+		//     Gets the parent bone for this mesh. The parent bone of a mesh contains a
+		//     transformation matrix that describes how the mesh is located relative to
+		//     any parent meshes in a model.
+		public ModelBone ParentBone { get; set; }
+		//
+		// Summary:
+		//     Gets or sets an object identifying this mesh.
+		public object Tag { get; set; }
+				
+		// Summary:
+		//     Draws all of the ModelMeshPart objects in this mesh, using their current
+		//     Effect settings.
+		public void Draw()
+		{	
+			for(int i = 0; i < MeshParts.Count; i++)
+			{
+				var part = MeshParts[i];
+				var effect = part.Effect;
+				
+				if (part.PrimitiveCount > 0)
+				{
+                    this.graphicsDevice.SetVertexBuffer(part.VertexBuffer);
+                    this.graphicsDevice.Indices = part.IndexBuffer;
+                    
+                    for (int j = 0; j < effect.CurrentTechnique.Passes.Count; j++)
+                    {
+						effect.CurrentTechnique.Passes[j].Apply ();
+						graphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, part.VertexOffset, part.StartIndex, part.PrimitiveCount);
+					}
+				}
+			}
+		}
+	}
+
+
+	//// Summary:
+	////     Represents a mesh that is part of a Model.
+	//public sealed class ModelMesh
+	//{
+	//    // Summary:
+	//    //     Gets the BoundingSphere that contains this mesh.
+	//    public BoundingSphere BoundingSphere { get { throw new NotImplementedException(); } }
+	//    //
+	//    // Summary:
+	//    //     Gets a collection of effects associated with this mesh.
+	//    public ModelEffectCollection Effects { get { throw new NotImplementedException(); } }
+	//    //
+	//    // Summary:
+	//    //     Gets the ModelMeshPart objects that make up this mesh. Each part of a mesh
+	//    //     is composed of a set of primitives that share the same material.
+	//    public ModelMeshPartCollection MeshParts { get { throw new NotImplementedException(); } }
+	//    //
+	//    // Summary:
+	//    //     Gets the name of this mesh.
+	//    public string Name { get { throw new NotImplementedException(); } }
+	//    //
+	//    // Summary:
+	//    //     Gets the parent bone for this mesh. The parent bone of a mesh contains a
+	//    //     transformation matrix that describes how the mesh is located relative to
+	//    //     any parent meshes in a model.
+	//    public ModelBone ParentBone { get { throw new NotImplementedException(); } }
+	//    //
+	//    // Summary:
+	//    //     Gets or sets an object identifying this mesh.
+	//    public object Tag { get { throw new NotImplementedException(); } set { throw new NotImplementedException(); } }
+
+	//    // Summary:
+	//    //     Draws all of the ModelMeshPart objects in this mesh, using their current
+	//    //     Effect settings.
+	//    public void Draw() { throw new NotImplementedException(); }
+	//}
+}
diff --git a/MonoGame.Framework/Graphics/ModelMeshCollection.cs b/MonoGame.Framework/Graphics/ModelMeshCollection.cs
new file mode 100644
index 00000000000..c9461a3d997
--- /dev/null
+++ b/MonoGame.Framework/Graphics/ModelMeshCollection.cs
@@ -0,0 +1,126 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Represents a collection of ModelMesh objects.
+    /// </summary>
+    public sealed class ModelMeshCollection : ReadOnlyCollection<ModelMesh>
+    {
+        internal ModelMeshCollection(IList<ModelMesh> list)
+            : base(list)
+        {
+
+        }
+
+        /// <summary>
+        /// Retrieves a ModelMesh from the collection, given the name of the mesh.
+        /// </summary>
+        /// <param name="meshName">The name of the mesh to retrieve.</param>
+        public ModelMesh this[string meshName]
+        {
+            get
+            {
+                ModelMesh ret;
+                if (!TryGetValue(meshName, out ret))
+                    throw new KeyNotFoundException();
+                return ret;
+            }
+        }
+
+        /// <summary>
+        /// Finds a mesh with a given name if it exists in the collection.
+        /// </summary>
+        /// <param name="meshName">The name of the mesh to find.</param>
+        /// <param name="value">The mesh named meshName, if found.</param>
+        /// <returns>true if a mesh was found</returns>
+        public bool TryGetValue(string meshName, out ModelMesh value)
+        {
+            if (string.IsNullOrEmpty(meshName))
+                throw new ArgumentNullException("meshName");
+
+            foreach (var mesh in this)
+            {
+                if (string.Compare(mesh.Name, meshName, StringComparison.Ordinal) == 0)
+                {
+                    value = mesh;
+                    return true;
+                }
+            }
+
+            value = null;
+            return false;
+        }
+
+        /// <summary>
+        /// Returns a ModelMeshCollection.Enumerator that can iterate through a ModelMeshCollection.
+        /// </summary>
+        /// <returns></returns>
+        public new Enumerator GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        /// <summary>
+        /// Provides the ability to iterate through the bones in an ModelMeshCollection.
+        /// </summary>
+        public struct Enumerator : IEnumerator<ModelMesh>
+        {
+            private readonly ModelMeshCollection _collection;
+            private int _position;
+
+            internal Enumerator(ModelMeshCollection collection)
+            {
+                _collection = collection;
+                _position = -1;
+            }
+
+
+            /// <summary>
+            /// Gets the current element in the ModelMeshCollection.
+            /// </summary>
+            public ModelMesh Current { get { return _collection[_position]; } }
+
+            /// <summary>
+            /// Advances the enumerator to the next element of the ModelMeshCollection.
+            /// </summary>
+            public bool MoveNext()
+            {
+                _position++;
+                return (_position < _collection.Count);
+            }
+
+            #region IDisposable
+
+            /// <summary>
+            /// Immediately releases the unmanaged resources used by this object.
+            /// </summary>
+            public void Dispose()
+            {
+            }
+
+            #endregion
+
+            #region IEnumerator Members
+
+            object IEnumerator.Current
+            {
+                get { return _collection[_position]; }
+            }
+
+            public void Reset()
+            {
+                _position = -1;
+            }
+
+            #endregion
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/ModelMeshPart.cs b/MonoGame.Framework/Graphics/ModelMeshPart.cs
new file mode 100644
index 00000000000..57b8034b384
--- /dev/null
+++ b/MonoGame.Framework/Graphics/ModelMeshPart.cs
@@ -0,0 +1,69 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public sealed class ModelMeshPart
+	{
+        private Effect _effect;
+
+        public Effect Effect 
+        {
+            get 
+            {
+                return _effect;
+            }
+            set 
+            {
+                if (value == _effect)
+                    return;
+
+                if (_effect != null)
+                {
+                    // First check to see any other parts are also using this effect.
+                    var removeEffect = true;
+                    foreach (var part in parent.MeshParts)
+                    {
+                        if (part != this && part._effect == _effect)
+                        {
+                            removeEffect = false;
+                            break;
+                        }
+                    }
+
+                    if (removeEffect)
+                        parent.Effects.Remove(_effect);
+                }
+
+                // Set the new effect.
+                _effect = value;
+                
+                if (_effect != null && !parent.Effects.Contains(_effect))                
+                    parent.Effects.Add(_effect);
+            }
+        }
+
+		public IndexBuffer IndexBuffer { get; set; }
+
+		public int NumVertices { get; set; }
+
+		public int PrimitiveCount { get; set; }
+
+		public int StartIndex { get; set; }
+
+		public object Tag { get; set; }
+
+		public VertexBuffer VertexBuffer { get; set; }
+
+		public int VertexOffset { get; set; }
+
+		internal int VertexBufferIndex { get; set; }
+
+		internal int IndexBufferIndex { get; set; }
+
+		internal int EffectIndex { get; set; }
+		
+		internal ModelMesh parent;
+        
+        internal ModelMeshPart() { }
+	}
+}
diff --git a/MonoGame.Framework/Graphics/ModelMeshPartCollection.cs b/MonoGame.Framework/Graphics/ModelMeshPartCollection.cs
new file mode 100644
index 00000000000..0feda67d1a3
--- /dev/null
+++ b/MonoGame.Framework/Graphics/ModelMeshPartCollection.cs
@@ -0,0 +1,63 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+
+	public sealed class ModelMeshPartCollection : ReadOnlyCollection<ModelMeshPart>
+	{
+		public ModelMeshPartCollection(IList<ModelMeshPart> list)
+			: base(list)
+		{
+
+		}
+	}
+
+	//// Summary:
+	////     Represents a collection of ModelMeshPart objects.
+	//public sealed class ModelMeshPartCollection : ReadOnlyCollection<ModelMeshPart>
+	//{
+	//    internal ModelMeshPartCollection()
+	//        : base(new List<ModelMeshPart>())
+	//    {
+	//    }
+
+	//    // Summary:
+	//    //     Returns a ModelMeshPartCollection.Enumerator that can iterate through a ModelMeshPartCollection.
+	//    public ModelMeshPartCollection.Enumerator GetEnumerator() { throw new NotImplementedException(); }
+
+	//    // Summary:
+	//    //     Provides the ability to iterate through the bones in an ModelMeshPartCollection.
+	//    public struct Enumerator : IEnumerator<ModelMeshPart>, IDisposable, IEnumerator
+	//    {
+
+	//        // Summary:
+	//        //     Gets the current element in the ModelMeshPartCollection.
+	//        public ModelMeshPart Current { get { throw new NotImplementedException(); } }
+
+	//        // Summary:
+	//        //     Immediately releases the unmanaged resources used by this object.
+	//        public void Dispose() { throw new NotImplementedException(); }
+	//        //
+	//        // Summary:
+	//        //     Advances the enumerator to the next element of the ModelMeshPartCollection.
+	//        public bool MoveNext() { throw new NotImplementedException(); }
+
+	//        #region IEnumerator Members
+
+	//        object IEnumerator.Current
+	//        {
+	//            get { throw new NotImplementedException(); }
+	//        }
+
+	//        public void Reset()
+	//        {
+	//            throw new NotImplementedException();
+	//        }
+
+	//        #endregion
+	//    }
+	//}
+}
diff --git a/MonoGame.Framework/Graphics/NoSuitableGraphicsDeviceException.cs b/MonoGame.Framework/Graphics/NoSuitableGraphicsDeviceException.cs
new file mode 100644
index 00000000000..a2b53280da0
--- /dev/null
+++ b/MonoGame.Framework/Graphics/NoSuitableGraphicsDeviceException.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    [DataContract]
+    public sealed class NoSuitableGraphicsDeviceException : Exception
+    {
+        public NoSuitableGraphicsDeviceException()
+            : base()
+        {
+
+        }
+
+        public NoSuitableGraphicsDeviceException(string message)
+            : base(message)
+        {
+
+        }
+
+        public NoSuitableGraphicsDeviceException(string message, Exception inner)
+            : base(message, inner)
+        {
+
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/OcclusionQuery.DirectX.cs b/MonoGame.Framework/Graphics/OcclusionQuery.DirectX.cs
new file mode 100644
index 00000000000..54bb7ada431
--- /dev/null
+++ b/MonoGame.Framework/Graphics/OcclusionQuery.DirectX.cs
@@ -0,0 +1,65 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using SharpDX.Direct3D11;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    partial class OcclusionQuery
+    {
+        private Query _query;
+
+        private void PlatformConstruct()
+        {
+            //if (graphicsDevice._d3dDevice.FeatureLevel == SharpDX.Direct3D.FeatureLevel.Level_9_1)
+            //    throw new NotSupportedException("The Reach profile does not support occlusion queries.");
+
+            var queryDescription = new QueryDescription
+            {
+                Flags = QueryFlags.None,
+                Type = QueryType.Occlusion
+            };
+            _query = new Query(GraphicsDevice._d3dDevice, queryDescription);
+        }
+        
+        private void PlatformBegin()
+        {
+            var d3dContext = GraphicsDevice._d3dContext;
+            lock(d3dContext)
+                d3dContext.Begin(_query);
+        }
+
+        private void PlatformEnd()
+        {
+            var d3dContext = GraphicsDevice._d3dContext;
+            lock (d3dContext)
+                d3dContext.End(_query);
+        }
+
+        private bool PlatformGetResult(out int pixelCount)
+        {
+            var d3dContext = GraphicsDevice._d3dContext;
+            ulong count;
+            bool isComplete;
+
+            lock (d3dContext)
+                isComplete = d3dContext.GetData(_query, out count);
+
+            pixelCount = (int)count;
+            return isComplete;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                if (disposing)
+                    _query.Dispose();
+            }
+
+            base.Dispose(disposing);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/OcclusionQuery.Null.cs b/MonoGame.Framework/Graphics/OcclusionQuery.Null.cs
new file mode 100644
index 00000000000..9c2039f83d1
--- /dev/null
+++ b/MonoGame.Framework/Graphics/OcclusionQuery.Null.cs
@@ -0,0 +1,28 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    partial class OcclusionQuery
+    {
+        private void PlatformConstruct()
+        {
+        }
+
+        private void PlatformBegin()
+        {
+        }
+
+        private void PlatformEnd()
+        {
+        }
+
+        private bool PlatformGetResult(out int pixelCount)
+        {
+            pixelCount = 0;
+            return false;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/OcclusionQuery.OpenGL.cs b/MonoGame.Framework/Graphics/OcclusionQuery.OpenGL.cs
new file mode 100644
index 00000000000..4d242a693c7
--- /dev/null
+++ b/MonoGame.Framework/Graphics/OcclusionQuery.OpenGL.cs
@@ -0,0 +1,64 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    partial class OcclusionQuery
+    {
+        private int glQueryId = -1;
+
+        private void PlatformConstruct()
+        {
+            GL.GenQueries(1, out glQueryId);
+            GraphicsExtensions.CheckGLError();
+        }
+
+        private void PlatformBegin()
+        {
+            GL.BeginQuery(QueryTarget.SamplesPassed, glQueryId);
+            GraphicsExtensions.CheckGLError();
+        }
+
+        private void PlatformEnd()
+        {
+            GL.EndQuery(QueryTarget.SamplesPassed);
+            GraphicsExtensions.CheckGLError();
+        }
+
+        private bool PlatformGetResult(out int pixelCount)
+        {
+            int resultReady = 0;
+            GL.GetQueryObject(glQueryId, GetQueryObjectParam.QueryResultAvailable, out resultReady);
+            GraphicsExtensions.CheckGLError();
+
+            if (resultReady == 0)
+            {
+                pixelCount = 0;
+                return false;
+            }
+
+            GL.GetQueryObject(glQueryId, GetQueryObjectParam.QueryResult, out pixelCount);
+            GraphicsExtensions.CheckGLError();
+
+            return true;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                if (glQueryId > -1)
+                {
+                    GraphicsDevice.DisposeQuery(glQueryId);
+                    glQueryId = -1;
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/OcclusionQuery.cs b/MonoGame.Framework/Graphics/OcclusionQuery.cs
new file mode 100644
index 00000000000..718e990cf52
--- /dev/null
+++ b/MonoGame.Framework/Graphics/OcclusionQuery.cs
@@ -0,0 +1,114 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class OcclusionQuery : GraphicsResource
+    {
+        private bool _inBeginEndPair;  // true if Begin was called and End was not yet called.
+        private bool _queryPerformed;  // true if Begin+End were called at least once.
+        private bool _isComplete;      // true if the result is available in _pixelCount.
+        private int _pixelCount;       // The query result.
+
+        /// <summary>
+        /// Gets a value indicating whether the occlusion query has completed.
+        /// </summary>
+        /// <value>
+        /// <see langword="true"/> if the occlusion query has completed; otherwise,
+        /// <see langword="false"/>.
+        /// </value>
+        public bool IsComplete
+        {
+            get
+            {
+                if (_isComplete)
+                    return true;
+
+                if (!_queryPerformed || _inBeginEndPair)
+                    return false;
+
+                _isComplete = PlatformGetResult(out _pixelCount);
+
+                return _isComplete;
+            }
+        }
+
+        /// <summary>
+        /// Gets the number of visible pixels.
+        /// </summary>
+        /// <value>The number of visible pixels.</value>
+        /// <exception cref="InvalidOperationException">
+        /// The occlusion query has not yet completed. Check <see cref="IsComplete"/> before reading
+        /// the result!
+        /// </exception>
+        public int PixelCount
+        {
+            get
+            {
+                if (!IsComplete)
+                    throw new InvalidOperationException("The occlusion query has not yet completed. Check IsComplete before reading the result.");
+
+                return _pixelCount;
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OcclusionQuery"/> class.
+        /// </summary>
+        /// <param name="graphicsDevice">The graphics device.</param>
+        /// <exception cref="ArgumentNullException">
+        /// <paramref name="graphicsDevice"/> is <see langword="null"/>.
+        /// </exception>
+        /// <exception cref="NotSupportedException">
+        /// The current graphics profile does not support occlusion queries.
+        /// </exception>
+        public OcclusionQuery(GraphicsDevice graphicsDevice)
+        {
+            if (graphicsDevice == null)
+                throw new ArgumentNullException("graphicsDevice");
+            if (graphicsDevice.GraphicsProfile == GraphicsProfile.Reach)
+                throw new NotSupportedException("The Reach profile does not support occlusion queries.");
+
+            GraphicsDevice = graphicsDevice;
+
+            PlatformConstruct();
+        }
+
+        /// <summary>
+        /// Begins the occlusion query.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">
+        /// <see cref="Begin"/> is called again before calling <see cref="End"/>.
+        /// </exception>
+        public void Begin()
+        {
+            if (_inBeginEndPair)
+                throw new InvalidOperationException("End() must be called before calling Begin() again.");
+
+            _inBeginEndPair = true;
+            _isComplete = false;
+
+            PlatformBegin();
+        }
+
+        /// <summary>
+        /// Ends the occlusion query.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">
+        /// <see cref="End"/> is called before calling <see cref="Begin"/>.
+        /// </exception>
+        public void End()
+        {
+            if (!_inBeginEndPair)
+                throw new InvalidOperationException("Begin() must be called before calling End().");
+
+            _inBeginEndPair = false;
+            _queryPerformed = true;
+
+            PlatformEnd();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/OpenGL.Android.cs b/MonoGame.Framework/Graphics/OpenGL.Android.cs
new file mode 100644
index 00000000000..0ec6f7ecc2d
--- /dev/null
+++ b/MonoGame.Framework/Graphics/OpenGL.Android.cs
@@ -0,0 +1,105 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Security;
+using Android.Opengl;
+using Javax.Microedition.Khronos.Egl;
+using MonoGame.Utilities;
+
+namespace MonoGame.OpenGL
+{
+    internal partial class GL
+    {
+		// internal for Android is not used on other platforms
+		// it allows us to use either GLES or Full GL (if the GPU supports it)
+		internal delegate bool BindAPIDelegate (RenderApi api);
+		internal static BindAPIDelegate BindAPI;
+
+        public static IntPtr Library;
+        public static IntPtr libES1 = FuncLoader.LoadLibrary("libGLESv1_CM.so");
+        public static IntPtr libES2 = FuncLoader.LoadLibrary("libGLESv2.so");
+        public static IntPtr libES3 = FuncLoader.LoadLibrary("libGLESv3.so");
+        public static IntPtr libGL = FuncLoader.LoadLibrary("libGL.so");
+
+        static partial void LoadPlatformEntryPoints()
+        {
+            Android.Util.Log.Verbose("GL", "Loading Entry Points");
+
+            var eglBindLoaded = false;
+            try
+            {
+                BindAPI = FuncLoader.LoadFunction<BindAPIDelegate>(libGL, "eglBindAPI", true);
+                eglBindLoaded = true;
+            }
+            catch { }
+
+            var supportsFullGL = eglBindLoaded && BindAPI (RenderApi.GL);
+            if (!supportsFullGL) {
+                if (eglBindLoaded)
+                    BindAPI (RenderApi.ES);
+                BoundApi = RenderApi.ES;
+            }
+                
+            Android.Util.Log.Verbose("GL", "Bound {0}", BoundApi);
+
+            if (GL.BoundApi == GL.RenderApi.ES && libES3 != IntPtr.Zero)
+                Library = libES3;
+
+            if (GL.BoundApi == GL.RenderApi.ES && libES2 != IntPtr.Zero)
+                Library = libES2;
+            else if (GL.BoundApi == GL.RenderApi.GL && libGL != IntPtr.Zero)
+                Library = libGL;
+        }
+
+        private static T LoadFunction<T>(string function, bool throwIfNotFound = false)
+        {
+            return FuncLoader.LoadFunction<T>(Library, function, throwIfNotFound);
+        }
+
+        private static IGraphicsContext PlatformCreateContext (IWindowInfo info)
+        {
+            return null;//new GraphicsContext(info);
+        }
+    }
+
+    struct GLESVersion
+    {
+        const int EglContextClientVersion = 0x3098;
+        const int EglContextMinorVersion = 0x30fb;
+
+        public int Major;
+        public int Minor;
+
+        internal int[] GetAttributes()
+        {
+            int minor = Minor > -1 ? EglContextMinorVersion : EGL10.EglNone;
+            return new int[] { EglContextClientVersion, Major, minor, Minor, EGL10.EglNone };
+        }
+
+        public override string ToString()
+        {
+            return string.Format("{0}.{1}", Major, Minor == -1 ? 0 : Minor);
+        }
+
+        internal static IEnumerable<GLESVersion> GetSupportedGLESVersions()
+        {
+            if (GL.libES3 != IntPtr.Zero)
+            {
+                yield return new GLESVersion { Major = 3, Minor = 2 };
+                yield return new GLESVersion { Major = 3, Minor = 1 };
+                yield return new GLESVersion { Major = 3, Minor = 0 };
+            }
+            if (GL.libES2 != IntPtr.Zero)
+            {
+                // We pass -1 becuase when requesting a GLES 2.0 context we
+                // dont provide the Minor version.
+                yield return new GLESVersion { Major = 2, Minor = -1 };
+            }
+            yield return new GLESVersion();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/OpenGL.Common.cs b/MonoGame.Framework/Graphics/OpenGL.Common.cs
new file mode 100644
index 00000000000..f39b872538a
--- /dev/null
+++ b/MonoGame.Framework/Graphics/OpenGL.Common.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace MonoGame.OpenGL
+{
+    // Required to allow platforms other than iOS use the same code.
+    // just don't include this on iOS
+    [AttributeUsage (AttributeTargets.Delegate)]
+    internal sealed class MonoNativeFunctionWrapper : Attribute
+    {
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/OpenGL.SDL.cs b/MonoGame.Framework/Graphics/OpenGL.SDL.cs
new file mode 100644
index 00000000000..a45c4643ad7
--- /dev/null
+++ b/MonoGame.Framework/Graphics/OpenGL.SDL.cs
@@ -0,0 +1,42 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace MonoGame.OpenGL
+{
+    partial class GL
+    {
+        static partial void LoadPlatformEntryPoints()
+        {
+            BoundApi = RenderApi.GL;
+        }
+
+        private static T LoadFunction<T>(string function, bool throwIfNotFound = false)
+        {
+            var ret = Sdl.GL.GetProcAddress(function);
+
+            if (ret == IntPtr.Zero)
+            {
+                if (throwIfNotFound)
+                    throw new EntryPointNotFoundException(function);
+
+                return default(T);
+            }
+
+#if NETSTANDARD
+            return Marshal.GetDelegateForFunctionPointer<T>(ret);
+#else
+            return (T)(object)Marshal.GetDelegateForFunctionPointer(ret, typeof(T));
+#endif
+        }
+
+        private static IGraphicsContext PlatformCreateContext (IWindowInfo info)
+        {
+            return new GraphicsContext(info);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/OpenGL.cs b/MonoGame.Framework/Graphics/OpenGL.cs
new file mode 100644
index 00000000000..a37749358f9
--- /dev/null
+++ b/MonoGame.Framework/Graphics/OpenGL.cs
@@ -0,0 +1,1552 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Runtime.CompilerServices;
+using System.Collections.Generic;
+using System.Diagnostics;
+using MonoGame.Utilities;
+
+#if __IOS__ || __TVOS__ || MONOMAC
+using ObjCRuntime;
+#endif
+
+namespace MonoGame.OpenGL
+{
+    internal enum BufferAccess
+    {
+        ReadOnly = 0x88B8,
+    }
+
+    internal enum BufferUsageHint
+    {
+        StreamDraw = 0x88E0,
+        StaticDraw = 0x88E4,
+    }
+
+    internal enum StencilFace
+    {
+        Front = 0x0404,
+        Back = 0x0405,
+    }
+    internal enum DrawBuffersEnum
+    {
+        UnsignedShort,
+        UnsignedInt,
+    }
+
+    internal enum ShaderType
+    {
+        VertexShader = 0x8B31,
+        FragmentShader = 0x8B30,
+    }
+
+    internal enum ShaderParameter
+    {
+        LogLength = 0x8B84,
+        CompileStatus = 0x8B81,
+        SourceLength = 0x8B88,
+    }
+
+    internal enum GetProgramParameterName
+    {
+        LogLength = 0x8B84,
+        LinkStatus = 0x8B82,
+    }
+
+    internal enum DrawElementsType
+    {
+        UnsignedShort = 0x1403,
+        UnsignedInt = 0x1405,
+    }
+
+    internal enum QueryTarget
+    {
+        SamplesPassed = 0x8914,
+        SamplesPassedExt = 0x8C2F,
+    }
+
+    internal enum GetQueryObjectParam
+    {
+        QueryResultAvailable = 0x8867,
+        QueryResult = 0x8866,
+    }
+
+    internal enum GenerateMipmapTarget
+    {
+        Texture1D = 0x0DE0,
+        Texture2D = 0x0DE1,
+        Texture3D = 0x806F,
+        TextureCubeMap = 0x8513,
+        Texture1DArray = 0x8C18,
+        Texture2DArray = 0x8C1A,
+        Texture2DMultisample = 0x9100,
+        Texture2DMultisampleArray = 0x9102,
+    }
+
+    internal enum BlitFramebufferFilter
+    {
+        Nearest = 0x2600,
+    }
+
+    internal enum ReadBufferMode
+    {
+        ColorAttachment0 = 0x8CE0,
+    }
+
+    internal enum DrawBufferMode
+    {
+        ColorAttachment0 = 0x8CE0,
+    }
+
+    internal enum FramebufferErrorCode
+    {
+        FramebufferUndefined = 0x8219,
+        FramebufferComplete = 0x8CD5,
+        FramebufferCompleteExt = 0x8CD5,
+        FramebufferIncompleteAttachment = 0x8CD6,
+        FramebufferIncompleteAttachmentExt = 0x8CD6,
+        FramebufferIncompleteMissingAttachment = 0x8CD7,
+        FramebufferIncompleteMissingAttachmentExt = 0x8CD7,
+        FramebufferIncompleteDimensionsExt = 0x8CD9,
+        FramebufferIncompleteFormatsExt = 0x8CDA,
+        FramebufferIncompleteDrawBuffer = 0x8CDB,
+        FramebufferIncompleteDrawBufferExt = 0x8CDB,
+        FramebufferIncompleteReadBuffer = 0x8CDC,
+        FramebufferIncompleteReadBufferExt = 0x8CDC,
+        FramebufferUnsupported = 0x8CDD,
+        FramebufferUnsupportedExt = 0x8CDD,
+        FramebufferIncompleteMultisample = 0x8D56,
+        FramebufferIncompleteLayerTargets = 0x8DA8,
+        FramebufferIncompleteLayerCount = 0x8DA9,
+    }
+
+    internal enum BufferTarget
+    {
+        ArrayBuffer = 0x8892,
+        ElementArrayBuffer = 0x8893,
+    }
+
+    internal enum RenderbufferTarget
+    {
+        Renderbuffer = 0x8D41,
+        RenderbufferExt = 0x8D41,
+    }
+
+    internal enum FramebufferTarget
+    {
+        Framebuffer = 0x8D40,
+        FramebufferExt = 0x8D40,
+        ReadFramebuffer = 0x8CA8,
+    }
+
+    internal enum RenderbufferStorage
+    {
+        Rgba8 = 0x8058,
+        DepthComponent16 = 0x81a5,
+        DepthComponent24 = 0x81a6,
+        Depth24Stencil8 = 0x88F0,
+        // GLES Values
+        DepthComponent24Oes = 0x81A6,
+        Depth24Stencil8Oes = 0x88F0,
+        StencilIndex8 = 0x8D48,
+    }
+
+    internal enum EnableCap : int
+    {
+        PointSmooth = 0x0B10,
+        LineSmooth = 0x0B20,
+        CullFace = 0x0B44,
+        Lighting = 0x0B50,
+        ColorMaterial = 0x0B57,
+        Fog = 0x0B60,
+        DepthTest = 0x0B71,
+        StencilTest = 0x0B90,
+        Normalize = 0x0BA1,
+        AlphaTest = 0x0BC0,
+        Dither = 0x0BD0,
+        Blend = 0x0BE2,
+        ColorLogicOp = 0x0BF2,
+        ScissorTest = 0x0C11,
+        Texture2D = 0x0DE1,
+        PolygonOffsetFill = 0x8037,
+        RescaleNormal = 0x803A,
+        VertexArray = 0x8074,
+        NormalArray = 0x8075,
+        ColorArray = 0x8076,
+        TextureCoordArray = 0x8078,
+        Multisample = 0x809D,
+        SampleAlphaToCoverage = 0x809E,
+        SampleAlphaToOne = 0x809F,
+        SampleCoverage = 0x80A0,
+        DebugOutputSynchronous = 0x8242,
+        DebugOutput = 0x92E0,
+    }
+
+    internal enum VertexPointerType
+    {
+        Float = 0x1406,
+        Short = 0x1402,
+    }
+
+    internal enum VertexAttribPointerType
+    {
+        Float = 0x1406,
+        Short = 0x1402,
+        UnsignedByte = 0x1401,
+        HalfFloat = 0x140B,
+    }
+
+    internal enum CullFaceMode
+    {
+        Back = 0x0405,
+        Front = 0x0404,
+    }
+
+    internal enum FrontFaceDirection
+    {
+        Cw = 0x0900,
+        Ccw = 0x0901,
+    }
+
+    internal enum MaterialFace
+    {
+        FrontAndBack = 0x0408,
+    }
+
+    internal enum PolygonMode
+    {
+        Fill = 0x1B02,
+        Line = 0x1B01,
+    }
+
+    internal enum ColorPointerType
+    {
+        Float = 0x1406,
+        Short = 0x1402,
+        UnsignedShort = 0x1403,
+        UnsignedByte = 0x1401,
+        HalfFloat = 0x140B,
+    }
+
+    internal enum NormalPointerType
+    {
+        Byte = 0x1400,
+        Float = 0x1406,
+        Short = 0x1402,
+        UnsignedShort = 0x1403,
+        UnsignedByte = 0x1401,
+        HalfFloat = 0x140B,
+    }
+
+    internal enum TexCoordPointerType
+    {
+        Byte = 0x1400,
+        Float = 0x1406,
+        Short = 0x1402,
+        UnsignedShort = 0x1403,
+        UnsignedByte = 0x1401,
+        HalfFloat = 0x140B,
+    }
+
+    internal enum BlendEquationMode
+    {
+        FuncAdd = 0x8006,
+        Max = 0x8008,  // ios MaxExt
+        Min = 0x8007,  // ios MinExt
+        FuncReverseSubtract = 0x800B,
+        FuncSubtract = 0x800A,
+    }
+
+    internal enum BlendingFactorSrc
+    {
+        Zero = 0,
+        SrcColor = 0x0300,
+        OneMinusSrcColor = 0x0301,
+        SrcAlpha = 0x0302,
+        OneMinusSrcAlpha = 0x0303,
+        DstAlpha = 0x0304,
+        OneMinusDstAlpha = 0x0305,
+        DstColor = 0x0306,
+        OneMinusDstColor = 0x0307,
+        SrcAlphaSaturate = 0x0308,
+        ConstantColor = 0x8001,
+        OneMinusConstantColor = 0x8002,
+        ConstantAlpha = 0x8003,
+        OneMinusConstantAlpha = 0x8004,
+        One = 1,
+    }
+
+    internal enum BlendingFactorDest
+    {
+        Zero = 0,
+        SrcColor = 0x0300,
+        OneMinusSrcColor = 0x0301,
+        SrcAlpha = 0x0302,
+        OneMinusSrcAlpha = 0x0303,
+        DstAlpha = 0x0304,
+        OneMinusDstAlpha = 0x0305,
+        DstColor = 0X0306,
+        OneMinusDstColor = 0x0307,
+        SrcAlphaSaturate = 0x0308,
+        ConstantColor = 0x8001,
+        OneMinusConstantColor = 0x8002,
+        ConstantAlpha = 0x8003,
+        OneMinusConstantAlpha = 0x8004,
+        One = 1,
+    }
+
+    internal enum DepthFunction
+    {
+        Always = 0x0207,
+        Equal = 0x0202,
+        Greater = 0x0204,
+        Gequal = 0x0206,
+        Less = 0x0201,
+        Lequal = 0x0203,
+        Never = 0x0200,
+        Notequal = 0x0205,
+    }
+
+    internal enum GetPName : int
+    {
+        ArrayBufferBinding = 0x8894,
+        MaxTextureImageUnits = 0x8872,
+        MaxVertexAttribs = 0x8869,
+        MaxTextureSize = 0x0D33,
+        MaxDrawBuffers = 0x8824,
+        TextureBinding2D = 0x8069,
+        MaxTextureMaxAnisotropyExt = 0x84FF,
+        MaxSamples = 0x8D57,
+    }
+
+    internal enum StringName
+    {
+        Extensions = 0x1F03,
+        Version = 0x1F02,
+    }
+
+    internal enum FramebufferAttachment
+    {
+        ColorAttachment0 = 0x8CE0,
+        ColorAttachment0Ext = 0x8CE0,
+        DepthAttachment = 0x8D00,
+        StencilAttachment = 0x8D20,
+        ColorAttachmentExt = 0x1800,
+        DepthAttachementExt = 0x1801,
+        StencilAttachmentExt = 0x1802,
+    }
+
+    internal enum GLPrimitiveType
+    {
+        Lines = 0x0001,
+        LineStrip = 0x0003,
+        Triangles = 0x0004,
+        TriangleStrip = 0x0005,
+    }
+
+    [Flags]
+    internal enum ClearBufferMask
+    {
+        DepthBufferBit = 0x00000100,
+        StencilBufferBit = 0x00000400,
+        ColorBufferBit = 0x00004000,
+    }
+
+    internal enum ErrorCode
+    {
+        NoError = 0,
+    }
+
+    internal enum TextureUnit
+    {
+        Texture0 = 0x84C0,
+    }
+
+    internal enum TextureTarget
+    {
+        Texture2D = 0x0DE1,
+        Texture3D = 0x806F,
+        TextureCubeMap = 0x8513,
+        TextureCubeMapPositiveX = 0x8515,
+        TextureCubeMapPositiveY = 0x8517,
+        TextureCubeMapPositiveZ = 0x8519,
+        TextureCubeMapNegativeX = 0x8516,
+        TextureCubeMapNegativeY = 0x8518,
+        TextureCubeMapNegativeZ = 0x851A,
+    }
+
+    internal enum PixelInternalFormat
+    {
+        Rgba = 0x1908,
+        Rgb = 0x1907,
+        Rgba4 = 0x8056,
+        Luminance = 0x1909,
+        CompressedRgbS3tcDxt1Ext = 0x83F0,
+        CompressedSrgbS3tcDxt1Ext = 0x8C4C,
+        CompressedRgbaS3tcDxt1Ext = 0x83F1,
+        CompressedRgbaS3tcDxt3Ext = 0x83F2,
+        CompressedSrgbAlphaS3tcDxt3Ext = 0x8C4E,
+        CompressedRgbaS3tcDxt5Ext = 0x83F3,
+        CompressedSrgbAlphaS3tcDxt5Ext = 0x8C4F,
+        R32f = 0x822E,
+        Rg16f = 0x822F,
+        Rgba16f = 0x881A,
+        R16f = 0x822D,
+        Rg32f = 0x8230,
+        Rgba32f = 0x8814,
+        Rg8i = 0x8237,
+        Rgba8i = 0x8D8E,
+        Rg16ui = 0x823A,
+        Rgba16ui = 0x8D76,
+        Rgb10A2ui = 0x906F,
+        Rgba16 = 0x805B,
+        // PVRTC
+        CompressedRgbPvrtc2Bppv1Img = 0x8C01,
+        CompressedRgbPvrtc4Bppv1Img = 0x8C00,
+        CompressedRgbaPvrtc2Bppv1Img = 0x8C03,
+        CompressedRgbaPvrtc4Bppv1Img = 0x8C02,
+        // ATITC
+        AtcRgbaExplicitAlphaAmd = 0x8C93,
+        AtcRgbaInterpolatedAlphaAmd = 0x87EE,
+        // ETC1
+        Etc1 = 0x8D64,
+        Srgb = 0x8C40,
+
+    }
+
+    internal enum PixelFormat
+    {
+        Rgba = 0x1908,
+        Rgb = 0x1907,
+        Luminance = 0x1909,
+        CompressedTextureFormats = 0x86A3,
+        Red = 0x1903,
+        Rg = 0x8227,
+    }
+
+    internal enum PixelType
+    {
+        UnsignedByte = 0x1401,
+        UnsignedShort565 = 0x8363,
+        UnsignedShort4444 = 0x8033,
+        UnsignedShort5551 = 0x8034,
+        Float = 0x1406,
+        HalfFloat = 0x140B,
+        HalfFloatOES = 0x8D61,
+        Byte = 0x1400,
+        UnsignedShort = 0x1403,
+        UnsignedInt1010102 = 0x8036,
+    }
+
+    internal enum PixelStoreParameter
+    {
+        UnpackAlignment = 0x0CF5,
+        PackAlignment = 0x0D05,
+    }
+
+    internal enum GLStencilFunction
+    {
+        Always = 0x0207,
+        Equal = 0x0202,
+        Greater = 0x0204,
+        Gequal = 0x0206,
+        Less = 0x0201,
+        Lequal = 0x0203,
+        Never = 0x0200,
+        Notequal = 0x0205,
+    }
+
+    internal enum StencilOp
+    {
+        Keep = 0x1E00,
+        DecrWrap = 0x8508,
+        Decr = 0x1E03,
+        Incr = 0x1E02,
+        IncrWrap = 0x8507,
+        Invert = 0x150A,
+        Replace = 0x1E01,
+        Zero = 0,
+    }
+
+    internal enum TextureParameterName
+    {
+        TextureMaxAnisotropyExt = 0x84FE,
+        TextureBaseLevel = 0x813C,
+        TextureMaxLevel = 0x813D,
+        TextureMinFilter = 0x2801,
+        TextureMagFilter = 0x2800,
+        TextureWrapS = 0x2802,
+        TextureWrapT = 0x2803,
+        TextureBorderColor = 0x1004,
+        TextureLodBias = 0x8501,
+        TextureCompareMode = 0x884C,
+        TextureCompareFunc = 0x884D,
+        GenerateMipmap = 0x8191,
+    }
+
+    internal enum Bool
+    {
+        True = 1,
+        False = 0,
+    }
+
+    internal enum TextureMinFilter
+    {
+        LinearMipmapNearest = 0x2701,
+        NearestMipmapLinear = 0x2702,
+        LinearMipmapLinear = 0x2703,
+        Linear = 0x2601,
+        NearestMipmapNearest = 0x2700,
+        Nearest = 0x2600,
+    }
+
+    internal enum TextureMagFilter
+    {
+        Linear = 0x2601,
+        Nearest = 0x2600,
+    }
+
+    internal enum TextureCompareMode
+    {
+        CompareRefToTexture = 0x884E,
+        None = 0,
+    }
+
+    internal enum TextureWrapMode
+    {
+        ClampToEdge = 0x812F,
+        Repeat = 0x2901,
+        MirroredRepeat = 0x8370,
+        //GLES
+        ClampToBorder = 0x812D,
+    }
+
+    internal partial class ColorFormat
+    {
+        internal ColorFormat (int r, int g, int b, int a)
+        {
+            R = r;
+            G = g;
+            B = b;
+            A = a;
+        }
+
+        internal int R { get; private set; }
+        internal int G { get; private set; }
+        internal int B { get; private set; }
+        internal int A { get; private set; }
+    }
+
+    internal partial class GL
+    {
+        internal enum RenderApi
+        {
+            ES = 12448,
+            GL = 12450,
+        }
+
+        internal static RenderApi BoundApi = RenderApi.GL;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void EnableVertexAttribArrayDelegate (int attrib);
+        internal static EnableVertexAttribArrayDelegate EnableVertexAttribArray;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DisableVertexAttribArrayDelegate (int attrib);
+        internal static DisableVertexAttribArrayDelegate DisableVertexAttribArray;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void MakeCurrentDelegate (IntPtr window);
+        internal static MakeCurrentDelegate MakeCurrent;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal unsafe delegate void GetIntegerDelegate (int param, [Out] int* data);
+        internal static GetIntegerDelegate GetIntegerv;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate IntPtr GetStringDelegate (StringName param);
+        internal static GetStringDelegate GetStringInternal;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void ClearDepthDelegate (float depth);
+        internal static ClearDepthDelegate ClearDepth;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DepthRangedDelegate (double min, double max);
+        internal static DepthRangedDelegate DepthRanged;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DepthRangefDelegate (float min, float max);
+        internal static DepthRangefDelegate DepthRangef;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void ClearDelegate (ClearBufferMask mask);
+        internal static ClearDelegate Clear;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void ClearColorDelegate (float red, float green, float blue, float alpha);
+        internal static ClearColorDelegate ClearColor;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void ClearStencilDelegate (int stencil);
+        internal static ClearStencilDelegate ClearStencil;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void ViewportDelegate (int x, int y, int w, int h);
+        internal static ViewportDelegate Viewport;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate ErrorCode GetErrorDelegate ();
+        internal static GetErrorDelegate GetError;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void FlushDelegate ();
+        internal static FlushDelegate Flush;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void GenTexturesDelegte (int count, [Out] out int id);
+        internal static GenTexturesDelegte GenTextures;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void BindTextureDelegate (TextureTarget target, int id);
+        internal static BindTextureDelegate BindTexture;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate int EnableDelegate (EnableCap cap);
+        internal static EnableDelegate Enable;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate int DisableDelegate (EnableCap cap);
+        internal static DisableDelegate Disable;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void CullFaceDelegate (CullFaceMode mode);
+        internal static CullFaceDelegate CullFace;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void FrontFaceDelegate (FrontFaceDirection direction);
+        internal static FrontFaceDelegate FrontFace;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void PolygonModeDelegate (MaterialFace face, PolygonMode mode);
+        internal static PolygonModeDelegate PolygonMode;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void PolygonOffsetDelegate (float slopeScaleDepthBias, float depthbias);
+        internal static PolygonOffsetDelegate PolygonOffset;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DrawBuffersDelegate (int count, DrawBuffersEnum [] buffers);
+        internal static DrawBuffersDelegate DrawBuffers;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void UseProgramDelegate (int program);
+        internal static UseProgramDelegate UseProgram;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal unsafe delegate void Uniform4fvDelegate (int location, int size, float* values);
+        internal static Uniform4fvDelegate Uniform4fv;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void Uniform1iDelegate (int location, int value);
+        internal static Uniform1iDelegate Uniform1i;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void ScissorDelegate (int x, int y, int width, int height);
+        internal static ScissorDelegate Scissor;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void ReadPixelsDelegate (int x, int y, int width, int height, PixelFormat format, PixelType type, IntPtr data);
+        internal static ReadPixelsDelegate ReadPixelsInternal;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void BindBufferDelegate (BufferTarget target, int buffer);
+        internal static BindBufferDelegate BindBuffer;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DrawElementsDelegate (GLPrimitiveType primitiveType, int count, DrawElementsType elementType, IntPtr offset);
+        internal static DrawElementsDelegate DrawElements;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DrawArraysDelegate (GLPrimitiveType primitiveType, int offset, int count);
+        internal static DrawArraysDelegate DrawArrays;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void GenRenderbuffersDelegate (int count, [Out] out int buffer);
+        internal static GenRenderbuffersDelegate GenRenderbuffers;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void BindRenderbufferDelegate (RenderbufferTarget target, int buffer);
+        internal static BindRenderbufferDelegate BindRenderbuffer;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DeleteRenderbuffersDelegate (int count, [In] [Out] ref int buffer);
+        internal static DeleteRenderbuffersDelegate DeleteRenderbuffers;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void RenderbufferStorageMultisampleDelegate (RenderbufferTarget target, int sampleCount,
+            RenderbufferStorage storage, int width, int height);
+        internal static RenderbufferStorageMultisampleDelegate RenderbufferStorageMultisample;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void GenFramebuffersDelegate (int count, out int buffer);
+        internal static GenFramebuffersDelegate GenFramebuffers;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void BindFramebufferDelegate (FramebufferTarget target, int buffer);
+        internal static BindFramebufferDelegate BindFramebuffer;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DeleteFramebuffersDelegate (int count, ref int buffer);
+        internal static DeleteFramebuffersDelegate DeleteFramebuffers;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        public delegate void InvalidateFramebufferDelegate (FramebufferTarget target, int numAttachments, FramebufferAttachment [] attachments);
+        public static InvalidateFramebufferDelegate InvalidateFramebuffer;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void FramebufferTexture2DDelegate (FramebufferTarget target, FramebufferAttachment attachement,
+            TextureTarget textureTarget, int texture, int level);
+        internal static FramebufferTexture2DDelegate FramebufferTexture2D;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void FramebufferTexture2DMultiSampleDelegate (FramebufferTarget target, FramebufferAttachment attachement,
+            TextureTarget textureTarget, int texture, int level, int samples);
+        internal static FramebufferTexture2DMultiSampleDelegate FramebufferTexture2DMultiSample;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void FramebufferRenderbufferDelegate (FramebufferTarget target, FramebufferAttachment attachement,
+            RenderbufferTarget renderBufferTarget, int buffer);
+        internal static FramebufferRenderbufferDelegate FramebufferRenderbuffer;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        public delegate void RenderbufferStorageDelegate (RenderbufferTarget target, RenderbufferStorage storage, int width, int hegiht);
+        public static RenderbufferStorageDelegate RenderbufferStorage;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void GenerateMipmapDelegate (GenerateMipmapTarget target);
+        internal static GenerateMipmapDelegate GenerateMipmap;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void ReadBufferDelegate (ReadBufferMode buffer);
+        internal static ReadBufferDelegate ReadBuffer;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DrawBufferDelegate (DrawBufferMode buffer);
+        internal static DrawBufferDelegate DrawBuffer;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void BlitFramebufferDelegate (int srcX0,
+            int srcY0,
+            int srcX1,
+            int srcY1,
+            int dstX0,
+            int dstY0,
+            int dstX1,
+            int dstY1,
+            ClearBufferMask mask,
+            BlitFramebufferFilter filter);
+        internal static BlitFramebufferDelegate BlitFramebuffer;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate FramebufferErrorCode CheckFramebufferStatusDelegate (FramebufferTarget target);
+        internal static CheckFramebufferStatusDelegate CheckFramebufferStatus;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void TexParameterFloatDelegate (TextureTarget target, TextureParameterName name, float value);
+        internal static TexParameterFloatDelegate TexParameterf;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal unsafe delegate void TexParameterFloatArrayDelegate (TextureTarget target, TextureParameterName name, float* values);
+        internal static TexParameterFloatArrayDelegate TexParameterfv;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void TexParameterIntDelegate (TextureTarget target, TextureParameterName name, int value);
+        internal static TexParameterIntDelegate TexParameteri;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void GenQueriesDelegate (int count, [Out] out int queryId);
+        internal static GenQueriesDelegate GenQueries;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void BeginQueryDelegate (QueryTarget target, int queryId);
+        internal static BeginQueryDelegate BeginQuery;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void EndQueryDelegate (QueryTarget target);
+        internal static EndQueryDelegate EndQuery;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void GetQueryObjectDelegate (int queryId, GetQueryObjectParam getparam, [Out] out int ready);
+        internal static GetQueryObjectDelegate GetQueryObject;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DeleteQueriesDelegate (int count, [In] [Out] ref int queryId);
+        internal static DeleteQueriesDelegate DeleteQueries;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void ActiveTextureDelegate (TextureUnit textureUnit);
+        internal static ActiveTextureDelegate ActiveTexture;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate int CreateShaderDelegate (ShaderType type);
+        internal static CreateShaderDelegate CreateShader;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal unsafe delegate void ShaderSourceDelegate (int shaderId, int count, IntPtr code, int* length);
+        internal static ShaderSourceDelegate ShaderSourceInternal;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void CompileShaderDelegate (int shaderId);
+        internal static CompileShaderDelegate CompileShader;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal unsafe delegate void GetShaderDelegate (int shaderId, int parameter, int* value);
+        internal static GetShaderDelegate GetShaderiv;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void GetShaderInfoLogDelegate (int shader, int bufSize, IntPtr length, StringBuilder infoLog);
+        internal static GetShaderInfoLogDelegate GetShaderInfoLogInternal;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate bool IsShaderDelegate (int shaderId);
+        internal static IsShaderDelegate IsShader;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DeleteShaderDelegate (int shaderId);
+        internal static DeleteShaderDelegate DeleteShader;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate int GetAttribLocationDelegate (int programId, string name);
+        internal static GetAttribLocationDelegate GetAttribLocation;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate int GetUniformLocationDelegate (int programId, string name);
+        internal static GetUniformLocationDelegate GetUniformLocation;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate bool IsProgramDelegate (int programId);
+        internal static IsProgramDelegate IsProgram;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DeleteProgramDelegate (int programId);
+        internal static DeleteProgramDelegate DeleteProgram;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate int CreateProgramDelegate ();
+        internal static CreateProgramDelegate CreateProgram;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void AttachShaderDelegate (int programId, int shaderId);
+        internal static AttachShaderDelegate AttachShader;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void LinkProgramDelegate (int programId);
+        internal static LinkProgramDelegate LinkProgram;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal unsafe delegate void GetProgramDelegate (int programId, int name, int* linked);
+        internal static GetProgramDelegate GetProgramiv;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void GetProgramInfoLogDelegate (int program, int bufSize, IntPtr length, StringBuilder infoLog);
+        internal static GetProgramInfoLogDelegate GetProgramInfoLogInternal;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DetachShaderDelegate (int programId, int shaderId);
+        internal static DetachShaderDelegate DetachShader;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void BlendColorDelegate (float r, float g, float b, float a);
+        internal static BlendColorDelegate BlendColor;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void BlendEquationSeparateDelegate (BlendEquationMode colorMode, BlendEquationMode alphaMode);
+        internal static BlendEquationSeparateDelegate BlendEquationSeparate;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void BlendFuncSeparateDelegate (BlendingFactorSrc colorSrc, BlendingFactorDest colorDst,
+            BlendingFactorSrc alphaSrc, BlendingFactorDest alphaDst);
+        internal static BlendFuncSeparateDelegate BlendFuncSeparate;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void ColorMaskDelegate (bool r, bool g, bool b, bool a);
+        internal static ColorMaskDelegate ColorMask;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DepthFuncDelegate (DepthFunction function);
+        internal static DepthFuncDelegate DepthFunc;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DepthMaskDelegate (bool enabled);
+        internal static DepthMaskDelegate DepthMask;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void StencilFuncSeparateDelegate (StencilFace face, GLStencilFunction function, int referenceStencil, int mask);
+        internal static StencilFuncSeparateDelegate StencilFuncSeparate;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void StencilOpSeparateDelegate (StencilFace face, StencilOp stencilfail, StencilOp depthFail, StencilOp pass);
+        internal static StencilOpSeparateDelegate StencilOpSeparate;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void StencilFuncDelegate (GLStencilFunction function, int referenceStencil, int mask);
+        internal static StencilFuncDelegate StencilFunc;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void StencilOpDelegate (StencilOp stencilfail, StencilOp depthFail, StencilOp pass);
+        internal static StencilOpDelegate StencilOp;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void StencilMaskDelegate (int mask);
+        internal static StencilMaskDelegate StencilMask;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void CompressedTexImage2DDelegate (TextureTarget target, int level, PixelInternalFormat internalFormat,
+            int width, int height, int border, int size, IntPtr data);
+        internal static CompressedTexImage2DDelegate CompressedTexImage2D;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void TexImage2DDelegate (TextureTarget target, int level, PixelInternalFormat internalFormat,
+            int width, int height, int border, PixelFormat format, PixelType pixelType, IntPtr data);
+        internal static TexImage2DDelegate TexImage2D;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void CompressedTexSubImage2DDelegate (TextureTarget target, int level,
+            int x, int y, int width, int height, PixelInternalFormat format, int size, IntPtr data);
+        internal static CompressedTexSubImage2DDelegate CompressedTexSubImage2D;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void TexSubImage2DDelegate (TextureTarget target, int level,
+            int x, int y, int width, int height, PixelFormat format, PixelType pixelType, IntPtr data);
+        internal static TexSubImage2DDelegate TexSubImage2D;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void PixelStoreDelegate (PixelStoreParameter parameter, int size);
+        internal static PixelStoreDelegate PixelStore;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void FinishDelegate ();
+        internal static FinishDelegate Finish;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void GetTexImageDelegate (TextureTarget target, int level, PixelFormat format, PixelType type, [Out] IntPtr pixels);
+        internal static GetTexImageDelegate GetTexImageInternal;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void GetCompressedTexImageDelegate (TextureTarget target, int level, [Out] IntPtr pixels);
+        internal static GetCompressedTexImageDelegate GetCompressedTexImageInternal;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void TexImage3DDelegate (TextureTarget target, int level, PixelInternalFormat internalFormat,
+            int width, int height, int depth, int border, PixelFormat format, PixelType pixelType, IntPtr data);
+        internal static TexImage3DDelegate TexImage3D;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void TexSubImage3DDelegate (TextureTarget target, int level,
+            int x, int y, int z, int width, int height, int depth, PixelFormat format, PixelType pixelType, IntPtr data);
+        internal static TexSubImage3DDelegate TexSubImage3D;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DeleteTexturesDelegate (int count, ref int id);
+        internal static DeleteTexturesDelegate DeleteTextures;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void GenBuffersDelegate (int count, out int buffer);
+        internal static GenBuffersDelegate GenBuffers;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void BufferDataDelegate (BufferTarget target, IntPtr size, IntPtr n, BufferUsageHint usage);
+        internal static BufferDataDelegate BufferData;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate IntPtr MapBufferDelegate (BufferTarget target, BufferAccess access);
+        internal static MapBufferDelegate MapBuffer;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void UnmapBufferDelegate (BufferTarget target);
+        internal static UnmapBufferDelegate UnmapBuffer;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void BufferSubDataDelegate (BufferTarget target, IntPtr offset, IntPtr size, IntPtr data);
+        internal static BufferSubDataDelegate BufferSubData;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DeleteBuffersDelegate (int count, [In] [Out] ref int buffer);
+        internal static DeleteBuffersDelegate DeleteBuffers;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void VertexAttribPointerDelegate (int location, int elementCount, VertexAttribPointerType type, bool normalize,
+            int stride, IntPtr data);
+        internal static VertexAttribPointerDelegate VertexAttribPointer;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void DrawElementsInstancedDelegate (GLPrimitiveType primitiveType, int count, DrawElementsType elementType,
+            IntPtr offset, int instanceCount);
+        internal static DrawElementsInstancedDelegate DrawElementsInstanced;
+
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        internal delegate void VertexAttribDivisorDelegate (int location, int frequency);
+        internal static VertexAttribDivisorDelegate VertexAttribDivisor;
+
+#if DEBUG
+        [UnmanagedFunctionPointer (CallingConvention.StdCall)]
+        delegate void DebugMessageCallbackProc (int source, int type, int id, int severity, int length, IntPtr message, IntPtr userParam);
+        static DebugMessageCallbackProc DebugProc;
+        [System.Security.SuppressUnmanagedCodeSecurity ()]
+        [MonoNativeFunctionWrapper]
+        delegate void DebugMessageCallbackDelegate (DebugMessageCallbackProc callback, IntPtr userParam);
+        static DebugMessageCallbackDelegate DebugMessageCallback;
+
+        internal delegate void ErrorDelegate (string message);
+        internal static event ErrorDelegate OnError;
+
+        static void DebugMessageCallbackHandler(int source, int type, int id, int severity, int length, IntPtr message, IntPtr userParam)
+        {
+            var errorMessage = Marshal.PtrToStringAnsi(message);
+            System.Diagnostics.Debug.WriteLine(errorMessage);
+            if (OnError != null)
+                OnError(errorMessage);
+        }
+#endif
+
+        internal static int SwapInterval { get; set; }
+
+        internal static void LoadEntryPoints ()
+        {
+            LoadPlatformEntryPoints ();
+
+            if (Viewport == null)
+                Viewport = LoadFunction<ViewportDelegate> ("glViewport");
+            if (Scissor == null)
+                Scissor = LoadFunction<ScissorDelegate> ("glScissor");
+            if (MakeCurrent == null)
+                MakeCurrent = LoadFunction<MakeCurrentDelegate> ("glMakeCurrent");
+
+            GetError = LoadFunction<GetErrorDelegate> ("glGetError");
+
+            TexParameterf = LoadFunction<TexParameterFloatDelegate> ("glTexParameterf");
+            TexParameterfv = LoadFunction<TexParameterFloatArrayDelegate> ("glTexParameterfv");
+            TexParameteri = LoadFunction<TexParameterIntDelegate> ("glTexParameteri");
+
+            EnableVertexAttribArray = LoadFunction<EnableVertexAttribArrayDelegate> ("glEnableVertexAttribArray");
+            DisableVertexAttribArray = LoadFunction<DisableVertexAttribArrayDelegate> ("glDisableVertexAttribArray");
+            GetIntegerv = LoadFunction<GetIntegerDelegate> ("glGetIntegerv");
+            GetStringInternal = LoadFunction<GetStringDelegate> ("glGetString");
+            ClearDepth = LoadFunction<ClearDepthDelegate> ("glClearDepth");
+            if (ClearDepth == null)
+                ClearDepth = LoadFunction<ClearDepthDelegate> ("glClearDepthf");
+            DepthRanged = LoadFunction<DepthRangedDelegate> ("glDepthRange");
+            DepthRangef = LoadFunction<DepthRangefDelegate> ("glDepthRangef");
+            Clear = LoadFunction<ClearDelegate> ("glClear");
+            ClearColor = LoadFunction<ClearColorDelegate> ("glClearColor");
+            ClearStencil = LoadFunction<ClearStencilDelegate> ("glClearStencil");
+            Flush = LoadFunction<FlushDelegate> ("glFlush");
+            GenTextures = LoadFunction<GenTexturesDelegte> ("glGenTextures");
+            BindTexture = LoadFunction<BindTextureDelegate> ("glBindTexture");
+
+            Enable = LoadFunction<EnableDelegate> ("glEnable");
+            Disable = LoadFunction<DisableDelegate> ("glDisable");
+            CullFace = LoadFunction<CullFaceDelegate> ("glCullFace");
+            FrontFace = LoadFunction<FrontFaceDelegate> ("glFrontFace");
+            PolygonMode = LoadFunction<PolygonModeDelegate> ("glPolygonMode");
+            PolygonOffset = LoadFunction<PolygonOffsetDelegate> ("glPolygonOffset");
+
+            BindBuffer = LoadFunction<BindBufferDelegate> ("glBindBuffer");
+            DrawBuffers = LoadFunction<DrawBuffersDelegate> ("glDrawBuffers");
+            DrawElements = LoadFunction<DrawElementsDelegate> ("glDrawElements");
+            DrawArrays = LoadFunction<DrawArraysDelegate> ("glDrawArrays");
+            Uniform1i = LoadFunction<Uniform1iDelegate> ("glUniform1i");
+            Uniform4fv = LoadFunction<Uniform4fvDelegate> ("glUniform4fv");
+            ReadPixelsInternal = LoadFunction<ReadPixelsDelegate>("glReadPixels");
+
+            ReadBuffer = LoadFunction<ReadBufferDelegate> ("glReadBuffer");
+            DrawBuffer = LoadFunction<DrawBufferDelegate> ("glDrawBuffer");
+
+            // Render Target Support. These might be null if they are not supported
+            // see GraphicsDevice.OpenGL.FramebufferHelper.cs for handling other extensions.
+            GenRenderbuffers = LoadFunction<GenRenderbuffersDelegate> ("glGenRenderbuffers");
+            BindRenderbuffer = LoadFunction<BindRenderbufferDelegate> ("glBindRenderbuffer");
+            DeleteRenderbuffers = LoadFunction<DeleteRenderbuffersDelegate> ("glDeleteRenderbuffers");
+            GenFramebuffers = LoadFunction<GenFramebuffersDelegate> ("glGenFramebuffers");
+            BindFramebuffer = LoadFunction<BindFramebufferDelegate> ("glBindFramebuffer");
+            DeleteFramebuffers = LoadFunction<DeleteFramebuffersDelegate> ("glDeleteFramebuffers");
+            FramebufferTexture2D = LoadFunction<FramebufferTexture2DDelegate> ("glFramebufferTexture2D");
+            FramebufferRenderbuffer = LoadFunction<FramebufferRenderbufferDelegate> ("glFramebufferRenderbuffer");
+            RenderbufferStorage = LoadFunction<RenderbufferStorageDelegate> ("glRenderbufferStorage");
+            RenderbufferStorageMultisample = LoadFunction<RenderbufferStorageMultisampleDelegate> ("glRenderbufferStorageMultisample");
+            GenerateMipmap = LoadFunction<GenerateMipmapDelegate> ("glGenerateMipmap");
+            BlitFramebuffer = LoadFunction<BlitFramebufferDelegate> ("glBlitFramebuffer");
+            CheckFramebufferStatus = LoadFunction<CheckFramebufferStatusDelegate> ("glCheckFramebufferStatus");
+
+            GenQueries = LoadFunction<GenQueriesDelegate> ("glGenQueries");
+            BeginQuery = LoadFunction<BeginQueryDelegate> ("glBeginQuery");
+            EndQuery = LoadFunction<EndQueryDelegate> ("glEndQuery");
+            GetQueryObject = LoadFunction<GetQueryObjectDelegate>("glGetQueryObjectuiv");
+            if (GetQueryObject == null)
+                GetQueryObject = LoadFunction<GetQueryObjectDelegate> ("glGetQueryObjectivARB");
+            if (GetQueryObject == null)
+                GetQueryObject = LoadFunction<GetQueryObjectDelegate> ("glGetQueryObjectiv");
+            DeleteQueries = LoadFunction<DeleteQueriesDelegate> ("glDeleteQueries");
+
+            ActiveTexture = LoadFunction<ActiveTextureDelegate> ("glActiveTexture");
+            CreateShader = LoadFunction<CreateShaderDelegate> ("glCreateShader");
+            ShaderSourceInternal = LoadFunction<ShaderSourceDelegate> ("glShaderSource");
+            CompileShader = LoadFunction<CompileShaderDelegate> ("glCompileShader");
+            GetShaderiv = LoadFunction<GetShaderDelegate> ("glGetShaderiv");
+            GetShaderInfoLogInternal = LoadFunction<GetShaderInfoLogDelegate> ("glGetShaderInfoLog");
+            IsShader = LoadFunction<IsShaderDelegate> ("glIsShader");
+            DeleteShader = LoadFunction<DeleteShaderDelegate> ("glDeleteShader");
+            GetAttribLocation = LoadFunction<GetAttribLocationDelegate> ("glGetAttribLocation");
+            GetUniformLocation = LoadFunction<GetUniformLocationDelegate> ("glGetUniformLocation");
+
+            IsProgram = LoadFunction<IsProgramDelegate> ("glIsProgram");
+            DeleteProgram = LoadFunction<DeleteProgramDelegate> ("glDeleteProgram");
+            CreateProgram = LoadFunction<CreateProgramDelegate> ("glCreateProgram");
+            AttachShader = LoadFunction<AttachShaderDelegate> ("glAttachShader");
+            UseProgram = LoadFunction<UseProgramDelegate> ("glUseProgram");
+            LinkProgram = LoadFunction<LinkProgramDelegate> ("glLinkProgram");
+            GetProgramiv = LoadFunction<GetProgramDelegate> ("glGetProgramiv");
+            GetProgramInfoLogInternal = LoadFunction<GetProgramInfoLogDelegate> ("glGetProgramInfoLog");
+            DetachShader = LoadFunction<DetachShaderDelegate> ("glDetachShader");
+
+            BlendColor = LoadFunction<BlendColorDelegate> ("glBlendColor");
+            BlendEquationSeparate = LoadFunction<BlendEquationSeparateDelegate> ("glBlendEquationSeparate");
+            BlendFuncSeparate = LoadFunction<BlendFuncSeparateDelegate> ("glBlendFuncSeparate");
+            ColorMask = LoadFunction<ColorMaskDelegate> ("glColorMask");
+            DepthFunc = LoadFunction<DepthFuncDelegate> ("glDepthFunc");
+            DepthMask = LoadFunction<DepthMaskDelegate> ("glDepthMask");
+            StencilFuncSeparate = LoadFunction<StencilFuncSeparateDelegate> ("glStencilFuncSeparate");
+            StencilOpSeparate = LoadFunction<StencilOpSeparateDelegate> ("glStencilOpSeparate");
+            StencilFunc = LoadFunction<StencilFuncDelegate> ("glStencilFunc");
+            StencilOp = LoadFunction<StencilOpDelegate> ("glStencilOp");
+            StencilMask = LoadFunction<StencilMaskDelegate> ("glStencilMask");
+
+            CompressedTexImage2D = LoadFunction<CompressedTexImage2DDelegate> ("glCompressedTexImage2D");
+            TexImage2D = LoadFunction<TexImage2DDelegate> ("glTexImage2D");
+            CompressedTexSubImage2D = LoadFunction<CompressedTexSubImage2DDelegate> ("glCompressedTexSubImage2D");
+            TexSubImage2D = LoadFunction<TexSubImage2DDelegate> ("glTexSubImage2D");
+            PixelStore = LoadFunction<PixelStoreDelegate> ("glPixelStorei");
+            Finish = LoadFunction<FinishDelegate> ("glFinish");
+            GetTexImageInternal = LoadFunction<GetTexImageDelegate> ("glGetTexImage");
+            GetCompressedTexImageInternal = LoadFunction<GetCompressedTexImageDelegate> ("glGetCompressedTexImage");
+            TexImage3D = LoadFunction<TexImage3DDelegate> ("glTexImage3D");
+            TexSubImage3D = LoadFunction<TexSubImage3DDelegate> ("glTexSubImage3D");
+            DeleteTextures = LoadFunction<DeleteTexturesDelegate> ("glDeleteTextures");
+
+            GenBuffers = LoadFunction<GenBuffersDelegate> ("glGenBuffers");
+            BufferData = LoadFunction<BufferDataDelegate> ("glBufferData");
+            MapBuffer = LoadFunction<MapBufferDelegate> ("glMapBuffer");
+            UnmapBuffer = LoadFunction<UnmapBufferDelegate> ("glUnmapBuffer");
+            BufferSubData = LoadFunction<BufferSubDataDelegate> ("glBufferSubData");
+            DeleteBuffers = LoadFunction<DeleteBuffersDelegate> ("glDeleteBuffers");
+
+            VertexAttribPointer = LoadFunction<VertexAttribPointerDelegate> ("glVertexAttribPointer");
+
+            // Instanced drawing requires GL 3.2 or up, if the either of the following entry points can not be loaded
+            // this will get flagged by setting SupportsInstancing in GraphicsCapabilities to false.
+            try {
+                DrawElementsInstanced = LoadFunction<DrawElementsInstancedDelegate> ("glDrawElementsInstanced");
+                VertexAttribDivisor = LoadFunction<VertexAttribDivisorDelegate> ("glVertexAttribDivisor");
+            } catch (EntryPointNotFoundException) {
+                // this will be detected in the initialization of GraphicsCapabilities
+            }
+
+#if DEBUG
+            try
+            {
+                DebugMessageCallback = LoadFunction<DebugMessageCallbackDelegate>("glDebugMessageCallback");
+                if (DebugMessageCallback != null)
+                {
+                    DebugProc = DebugMessageCallbackHandler;
+                    DebugMessageCallback(DebugProc, IntPtr.Zero);
+                    Enable(EnableCap.DebugOutput);
+                    Enable(EnableCap.DebugOutputSynchronous);
+                }
+            }
+            catch (EntryPointNotFoundException)
+            {
+                // Ignore the debug message callback if the entry point can not be found
+            }
+#endif
+            if (BoundApi == RenderApi.ES) {
+                InvalidateFramebuffer = LoadFunction<InvalidateFramebufferDelegate> ("glDiscardFramebufferEXT");
+            }
+
+            LoadExtensions ();
+        }
+
+        internal static List<string> Extensions = new List<string> ();
+
+        //[Conditional("DEBUG")]
+        //[DebuggerHidden]
+        static void LogExtensions()
+        {
+#if __ANDROID__
+            Android.Util.Log.Verbose("GL","Supported Extensions");
+            foreach (var ext in Extensions)
+                Android.Util.Log.Verbose("GL", "   " + ext);
+#endif
+        }
+
+        internal static void LoadExtensions()
+        {
+            string extstring = GL.GetString(StringName.Extensions);
+            var error = GL.GetError();
+            if (!string.IsNullOrEmpty(extstring) && error == ErrorCode.NoError)
+                Extensions.AddRange(extstring.Split(' '));
+
+            LogExtensions();
+            // now load Extensions :)
+            if (GL.GenRenderbuffers == null && Extensions.Contains("GL_EXT_framebuffer_object"))
+            {
+                GL.LoadFrameBufferObjectEXTEntryPoints();
+            }
+            if (GL.RenderbufferStorageMultisample == null)
+            {                
+                if (Extensions.Contains("GL_APPLE_framebuffer_multisample"))
+                {
+                    GL.RenderbufferStorageMultisample = LoadFunction<GL.RenderbufferStorageMultisampleDelegate>("glRenderbufferStorageMultisampleAPPLE");
+                    GL.BlitFramebuffer = LoadFunction<GL.BlitFramebufferDelegate>("glResolveMultisampleFramebufferAPPLE");
+                }
+                else if (Extensions.Contains("GL_EXT_multisampled_render_to_texture"))
+                {
+                    GL.RenderbufferStorageMultisample = LoadFunction<GL.RenderbufferStorageMultisampleDelegate>("glRenderbufferStorageMultisampleEXT");
+                    GL.FramebufferTexture2DMultiSample = LoadFunction<GL.FramebufferTexture2DMultiSampleDelegate>("glFramebufferTexture2DMultisampleEXT");
+
+                }
+                else if (Extensions.Contains("GL_IMG_multisampled_render_to_texture"))
+                {
+                    GL.RenderbufferStorageMultisample = LoadFunction<GL.RenderbufferStorageMultisampleDelegate>("glRenderbufferStorageMultisampleIMG");
+                    GL.FramebufferTexture2DMultiSample = LoadFunction<GL.FramebufferTexture2DMultiSampleDelegate>("glFramebufferTexture2DMultisampleIMG");
+                }
+                else if (Extensions.Contains("GL_NV_framebuffer_multisample"))
+                {
+                    GL.RenderbufferStorageMultisample = LoadFunction<GL.RenderbufferStorageMultisampleDelegate>("glRenderbufferStorageMultisampleNV");
+                    GL.BlitFramebuffer = LoadFunction<GL.BlitFramebufferDelegate>("glBlitFramebufferNV");
+                }
+            }
+        }
+
+        internal static void LoadFrameBufferObjectEXTEntryPoints()
+        {
+            GenRenderbuffers = LoadFunction<GenRenderbuffersDelegate>("glGenRenderbuffersEXT");
+            BindRenderbuffer = LoadFunction<BindRenderbufferDelegate>("glBindRenderbufferEXT");
+            DeleteRenderbuffers = LoadFunction<DeleteRenderbuffersDelegate>("glDeleteRenderbuffersEXT");
+            GenFramebuffers = LoadFunction<GenFramebuffersDelegate>("glGenFramebuffersEXT");
+            BindFramebuffer = LoadFunction<BindFramebufferDelegate>("glBindFramebufferEXT");
+            DeleteFramebuffers = LoadFunction<DeleteFramebuffersDelegate>("glDeleteFramebuffersEXT");
+            FramebufferTexture2D = LoadFunction<FramebufferTexture2DDelegate>("glFramebufferTexture2DEXT");
+            FramebufferRenderbuffer = LoadFunction<FramebufferRenderbufferDelegate>("glFramebufferRenderbufferEXT");
+            RenderbufferStorage = LoadFunction<RenderbufferStorageDelegate>("glRenderbufferStorageEXT");
+            RenderbufferStorageMultisample = LoadFunction<RenderbufferStorageMultisampleDelegate>("glRenderbufferStorageMultisampleEXT");
+            GenerateMipmap = LoadFunction<GenerateMipmapDelegate>("glGenerateMipmapEXT");
+            BlitFramebuffer = LoadFunction<BlitFramebufferDelegate>("glBlitFramebufferEXT");
+            CheckFramebufferStatus = LoadFunction<CheckFramebufferStatusDelegate>("glCheckFramebufferStatusEXT");
+        }
+
+        static partial void LoadPlatformEntryPoints();
+
+        internal static IGraphicsContext CreateContext(IWindowInfo info)
+        {
+            return PlatformCreateContext(info);
+        }
+
+        /* Helper Functions */
+
+        internal static void DepthRange(float min, float max)
+        {
+            if (BoundApi == RenderApi.ES)
+                DepthRangef(min, max);
+            else
+                DepthRanged(min, max);
+        }
+
+        internal static void Uniform1 (int location, int value) {
+            Uniform1i(location, value);
+        }
+
+        internal static unsafe void Uniform4 (int location, int size, float* value) {
+            Uniform4fv(location, size, value);
+        }
+
+        internal unsafe static string GetString (StringName name)
+        {
+            return Marshal.PtrToStringAnsi (GetStringInternal (name));
+        }
+
+        protected static IntPtr MarshalStringArrayToPtr (string[] strings)
+        {
+            IntPtr intPtr = IntPtr.Zero;
+            if (strings != null && strings.Length != 0) {
+                intPtr = Marshal.AllocHGlobal (strings.Length * IntPtr.Size);
+                if (intPtr == IntPtr.Zero) {
+                    throw new OutOfMemoryException ();
+                }
+                int i = 0;
+                try {
+                    for (i = 0; i < strings.Length; i++) {
+                        IntPtr val = MarshalStringToPtr (strings [i]);
+                        Marshal.WriteIntPtr (intPtr, i * IntPtr.Size, val);
+                    }
+                }
+                catch (OutOfMemoryException) {
+                    for (i--; i >= 0; i--) {
+                        Marshal.FreeHGlobal (Marshal.ReadIntPtr (intPtr, i * IntPtr.Size));
+                    }
+                    Marshal.FreeHGlobal (intPtr);
+                    throw;
+                }
+            }
+            return intPtr;
+        }
+
+        protected unsafe static IntPtr MarshalStringToPtr (string str)
+        {
+            if (string.IsNullOrEmpty (str)) {
+                return IntPtr.Zero;
+            }
+            int num = Encoding.ASCII.GetMaxByteCount (str.Length) + 1;
+            IntPtr intPtr = Marshal.AllocHGlobal (num);
+            if (intPtr == IntPtr.Zero) {
+                throw new OutOfMemoryException ();
+            }
+            fixed (char* chars = str + RuntimeHelpers.OffsetToStringData / 2) {
+                int bytes = Encoding.ASCII.GetBytes (chars, str.Length, (byte*)((void*)intPtr), num);
+                Marshal.WriteByte (intPtr, bytes, 0);
+                return intPtr;
+            }
+        }
+
+        protected static void FreeStringArrayPtr (IntPtr ptr, int length)
+        {
+            for (int i = 0; i < length; i++) {
+                Marshal.FreeHGlobal (Marshal.ReadIntPtr (ptr, i * IntPtr.Size));
+            }
+            Marshal.FreeHGlobal (ptr);
+        }
+
+        internal static string GetProgramInfoLog (int programId)
+        {
+            int length = 0;
+            GetProgram(programId, GetProgramParameterName.LogLength, out length);
+            var sb = new StringBuilder();
+            GetProgramInfoLogInternal (programId, length, IntPtr.Zero, sb);
+            return sb.ToString();
+        }
+
+        internal static string GetShaderInfoLog (int shaderId) {
+            int length = 0;
+            GetShader(shaderId, ShaderParameter.LogLength, out length);
+            var sb = new StringBuilder();
+            GetShaderInfoLogInternal (shaderId, length, IntPtr.Zero, sb);
+            return sb.ToString();
+        }
+
+        internal unsafe static void ShaderSource(int shaderId, string code)
+        {
+            int length = code.Length;
+            IntPtr intPtr = MarshalStringArrayToPtr (new string[] { code });
+            ShaderSourceInternal(shaderId, 1, intPtr, &length);
+            FreeStringArrayPtr(intPtr, 1);
+        }
+
+        internal unsafe static void GetShader (int shaderId, ShaderParameter name, out int result)
+        {
+            fixed (int* ptr = &result)
+            {
+                GetShaderiv(shaderId, (int)name, ptr);
+            }
+        }
+
+        internal unsafe static void GetProgram(int programId, GetProgramParameterName name, out int result)
+        {
+            fixed (int* ptr = &result)
+            {
+                GetProgramiv(programId, (int)name, ptr);
+            }
+        }
+
+        internal unsafe static void GetInteger (GetPName name, out int value)
+        {
+            fixed (int* ptr = &value) {
+                GetIntegerv ((int)name, ptr);
+            }
+        }
+
+        internal unsafe static void GetInteger (int name, out int value)
+        {
+            fixed (int* ptr = &value)
+            {
+                GetIntegerv (name, ptr);
+            }
+        }
+
+        internal static void TexParameter(TextureTarget target, TextureParameterName name, float value)
+        {
+            TexParameterf(target, name, value);
+        }
+
+        internal unsafe static void TexParameter(TextureTarget target, TextureParameterName name, float[] values)
+        {
+            fixed (float* ptr = &values[0])
+            {
+                TexParameterfv(target, name, ptr);
+            }
+        }
+
+        internal static void TexParameter(TextureTarget target, TextureParameterName name, int value)
+        {
+            TexParameteri(target, name, value);
+        }
+
+        internal static void GetTexImage<T>(TextureTarget target, int level, PixelFormat format, PixelType type, T[] pixels) where T : struct
+        {
+            var pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+            try
+            {
+                GetTexImageInternal(target, level, format, type, pixelsPtr.AddrOfPinnedObject());
+            }
+            finally
+            {
+                pixelsPtr.Free();
+            }
+        }
+
+        internal static void GetCompressedTexImage<T>(TextureTarget target, int level, T[] pixels) where T : struct
+        {
+            var pixelsPtr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+            try
+            {
+                GetCompressedTexImageInternal(target, level, pixelsPtr.AddrOfPinnedObject());
+            }
+            finally
+            {
+                pixelsPtr.Free();
+            }
+        }
+
+        public static void ReadPixels<T>(int x, int y, int width, int height, PixelFormat format, PixelType type, T[] data)
+        {
+            var dataPtr = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                ReadPixelsInternal(x, y, width, height, format, type, dataPtr.AddrOfPinnedObject());
+            }
+            finally
+            {
+                dataPtr.Free();
+            }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/OpenGL.iOS.cs b/MonoGame.Framework/Graphics/OpenGL.iOS.cs
new file mode 100644
index 00000000000..e0b73eb96d4
--- /dev/null
+++ b/MonoGame.Framework/Graphics/OpenGL.iOS.cs
@@ -0,0 +1,88 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.InteropServices;
+using ObjCRuntime;
+using System.Security;
+using OpenGLES;
+using MonoGame.Utilities;
+
+namespace MonoGame.OpenGL
+{
+    internal partial class GL
+	{
+        public static IntPtr Library = FuncLoader.LoadLibrary("/System/Library/Frameworks/OpenGLES.framework/OpenGLES");
+        
+        static partial void LoadPlatformEntryPoints()
+		{
+			BoundApi = RenderApi.ES;
+        }
+
+        private static T LoadFunction<T>(string function, bool throwIfNotFound = false)
+        {
+            return FuncLoader.LoadFunction<T>(Library, function, throwIfNotFound);
+        }
+
+        private static IGraphicsContext PlatformCreateContext (IWindowInfo info)
+        {
+            return new GraphicsContext ();
+        }
+	}
+
+    public class GraphicsContext : IGraphicsContext
+    {
+        public GraphicsContext ()
+        {
+            Context = new EAGLContext (EAGLRenderingAPI.OpenGLES2);
+        }
+
+        public bool IsCurrent {
+            get {
+                return EAGLContext.CurrentContext == this.Context;
+            }
+        }
+
+        public bool IsDisposed {
+            get {
+                return this.Context == null;
+            }
+        }
+
+        public int SwapInterval {
+            get {
+                throw new NotImplementedException ();
+            }
+
+            set {
+                throw new NotImplementedException ();
+            }
+        }
+
+        public void Dispose ()
+        {
+            if (this.Context != null) {
+                this.Context.Dispose ();
+            }
+            this.Context = null;
+        }
+
+        public void MakeCurrent (IWindowInfo info)
+        {
+            if (!EAGLContext.SetCurrentContext (this.Context)) {
+                throw new InvalidOperationException ("Unable to change current EAGLContext.");
+            }
+        }
+
+        public void SwapBuffers ()
+        {
+            if (!this.Context.PresentRenderBuffer (36161u)) {
+                throw new InvalidOperationException ("EAGLContext.PresentRenderbuffer failed.");
+            }
+        }
+
+        internal EAGLContext Context { get; private set; }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/PackedVector/Alpha8.cs b/MonoGame.Framework/Graphics/PackedVector/Alpha8.cs
new file mode 100644
index 00000000000..6b878f0df3b
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/Alpha8.cs
@@ -0,0 +1,128 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    /// <summary>
+    /// Packed vector type containing a single 8 bit normalized W values that is ranging from 0 to 1.
+    /// </summary>
+    public struct Alpha8 : IPackedVector<byte>, IEquatable<Alpha8>, IPackedVector
+    {
+        private byte packedValue;
+
+        /// <summary>
+        /// Gets and sets the packed value.
+        /// </summary>
+        [CLSCompliant(false)]
+        public byte PackedValue
+        {
+            get
+            {
+                return packedValue;
+            }
+            set
+            {
+                packedValue = value;
+            }
+        }
+
+        /// <summary>
+        /// Creates a new instance of Alpha8.
+        /// </summary>
+        /// <param name="alpha">The alpha component</param>
+        public Alpha8(float alpha)
+        {
+            packedValue = Pack(alpha);
+        }
+
+        /// <summary>
+        /// Gets the packed vector in float format.
+        /// </summary>
+        /// <returns>The packed vector in Vector3 format</returns>
+        public float ToAlpha()
+        {
+            return (float) (packedValue / 255.0f);
+        }
+
+        /// <summary>
+        /// Sets the packed vector from a Vector4.
+        /// </summary>
+        /// <param name="vector">Vector containing the components.</param>
+        void IPackedVector.PackFromVector4(Vector4 vector)
+        {
+            packedValue = Pack(vector.W);
+        }
+
+        /// <summary>
+        /// Gets the packed vector in Vector4 format.
+        /// </summary>
+        /// <returns>The packed vector in Vector4 format</returns>
+        Vector4 IPackedVector.ToVector4()
+        {
+            return new Vector4(
+                0.0f,
+                0.0f,
+                0.0f,
+                (float) (packedValue / 255.0f)
+            );
+        }
+
+        /// <summary>
+        /// Compares an object with the packed vector.
+        /// </summary>
+        /// <param name="obj">The object to compare.</param>
+        /// <returns>True if the object is equal to the packed vector.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is Alpha8) && Equals((Alpha8) obj);
+        }
+
+        /// <summary>
+        /// Compares another Alpha8 packed vector with the packed vector.
+        /// </summary>
+        /// <param name="other">The Alpha8 packed vector to compare.</param>
+        /// <returns>True if the packed vectors are equal.</returns>
+        public bool Equals(Alpha8 other)
+        {
+            return packedValue == other.packedValue;
+        }
+
+        /// <summary>
+        /// Gets a string representation of the packed vector.
+        /// </summary>
+        /// <returns>A string representation of the packed vector.</returns>
+        public override string ToString()
+        {
+            return (packedValue / 255.0f).ToString();
+        }
+
+        /// <summary>
+        /// Gets a hash code of the packed vector.
+        /// </summary>
+        /// <returns>The hash code for the packed vector.</returns>
+        public override int GetHashCode()
+        {
+            return packedValue.GetHashCode();
+        }
+
+        public static bool operator ==(Alpha8 lhs, Alpha8 rhs)
+        {
+            return lhs.packedValue == rhs.packedValue;
+        }
+
+        public static bool operator !=(Alpha8 lhs, Alpha8 rhs)
+        {
+            return lhs.packedValue != rhs.packedValue;
+        }
+
+        private static byte Pack(float alpha)
+        {
+            return (byte) Math.Round(
+                MathHelper.Clamp(alpha, 0, 1) * 255.0f
+            );
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/Bgr565.cs b/MonoGame.Framework/Graphics/PackedVector/Bgr565.cs
new file mode 100644
index 00000000000..e7b3d7cb73a
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/Bgr565.cs
@@ -0,0 +1,141 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    /// <summary>
+    /// Packed vector type containing unsigned normalized values ranging from 0 to 1. The x and z components use 5 bits, and the y component uses 6 bits.
+    /// </summary>
+    public struct Bgr565 : IPackedVector<UInt16>, IEquatable<Bgr565>, IPackedVector
+    {
+        UInt16 _packedValue;
+
+        private static UInt16 Pack(float x, float y, float z)
+        {
+            return (UInt16) ((((int) Math.Round(MathHelper.Clamp(x, 0, 1) * 31.0f) & 0x1F) << 11) |
+                (((int) Math.Round(MathHelper.Clamp(y, 0, 1) * 63.0f) & 0x3F) << 5) |
+                ((int) Math.Round(MathHelper.Clamp(z, 0, 1) * 31.0f) & 0x1F));
+        }
+
+        /// <summary>
+        /// Creates a new instance of Bgr565.
+        /// </summary>
+        /// <param name="x">The x component</param>
+        /// <param name="y">The y component</param>
+        /// <param name="z">The z component</param>
+        public Bgr565(float x, float y, float z)
+        {
+            _packedValue = Pack(x, y, z);
+        }
+
+        /// <summary>
+        /// Creates a new instance of Bgr565.
+        /// </summary>
+        /// <param name="vector">Vector containing the components for the packed vector.</param>
+        public Bgr565(Vector3 vector)
+        {
+            _packedValue = Pack(vector.X, vector.Y, vector.Z);
+        }
+
+        /// <summary>
+        /// Gets and sets the packed value.
+        /// </summary>
+        [CLSCompliant(false)]
+        public UInt16 PackedValue
+        {
+            get
+            {
+                return _packedValue;
+            }
+            set
+            {
+                _packedValue = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the packed vector in Vector3 format.
+        /// </summary>
+        /// <returns>The packed vector in Vector3 format</returns>
+        public Vector3 ToVector3()
+        {
+            return new Vector3((float)(((_packedValue >> 11) & 0x1F) * (1.0f / 31.0f)),
+                (float)(((_packedValue >> 5) & 0x3F) * (1.0f / 63.0f)),
+                (float)((_packedValue & 0x1F) * (1.0f / 31.0f))
+                );
+        }
+
+        /// <summary>
+        /// Sets the packed vector from a Vector4.
+        /// </summary>
+        /// <param name="vector">Vector containing the components.</param>
+        void IPackedVector.PackFromVector4(Vector4 vector)
+        {
+            _packedValue = (UInt16)((((int)(vector.X * 31.0f) & 0x1F) << 11) |
+                (((int)(vector.Y * 63.0f) & 0x3F) << 5) |
+                ((int)(vector.Z * 31.0f) & 0x1F));
+        }
+
+        /// <summary>
+        /// Gets the packed vector in Vector4 format.
+        /// </summary>
+        /// <returns>The packed vector in Vector4 format</returns>
+        Vector4 IPackedVector.ToVector4()
+        {
+            return new Vector4(ToVector3(), 1.0f);
+        }
+
+        /// <summary>
+        /// Compares an object with the packed vector.
+        /// </summary>
+        /// <param name="obj">The object to compare.</param>
+        /// <returns>true if the object is equal to the packed vector.</returns>
+        public override bool Equals(object obj)
+        {
+            if (obj != null && (obj is Bgr565))
+                return this == (Bgr565)obj;
+            return false;
+        }
+
+        /// <summary>
+        /// Compares another Bgr565 packed vector with the packed vector.
+        /// </summary>
+        /// <param name="other">The Bgr565 packed vector to compare.</param>
+        /// <returns>true if the packed vectors are equal.</returns>
+        public bool Equals(Bgr565 other)
+        {
+            return _packedValue == other._packedValue;
+        }
+
+        /// <summary>
+        /// Gets a string representation of the packed vector.
+        /// </summary>
+        /// <returns>A string representation of the packed vector.</returns>
+        public override string ToString()
+        {
+            return ToVector3().ToString();
+        }
+
+        /// <summary>
+        /// Gets a hash code of the packed vector.
+        /// </summary>
+        /// <returns>The hash code for the packed vector.</returns>
+        public override int GetHashCode()
+        {
+            return _packedValue.GetHashCode();
+        }
+
+        public static bool operator ==(Bgr565 lhs, Bgr565 rhs)
+        {
+            return lhs._packedValue == rhs._packedValue;
+        }
+
+        public static bool operator !=(Bgr565 lhs, Bgr565 rhs)
+        {
+            return lhs._packedValue != rhs._packedValue;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/Bgra4444.cs b/MonoGame.Framework/Graphics/PackedVector/Bgra4444.cs
new file mode 100644
index 00000000000..add9daadef5
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/Bgra4444.cs
@@ -0,0 +1,134 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    /// <summary>
+    /// Packed vector type containing unsigned normalized values, ranging from 0 to 1, using 4 bits each for x, y, z, and w.
+    /// </summary>
+    public struct Bgra4444 : IPackedVector<UInt16>, IEquatable<Bgra4444>
+    {
+        UInt16 _packedValue;
+
+        private static UInt16 Pack(float x, float y, float z, float w)
+        {
+            return (UInt16) ((((int) Math.Round(MathHelper.Clamp(w, 0, 1) * 15.0f) & 0x0F) << 12) |
+                (((int) Math.Round(MathHelper.Clamp(x, 0, 1) * 15.0f) & 0x0F) << 8) |
+                (((int) Math.Round(MathHelper.Clamp(y, 0, 1) * 15.0f) & 0x0F) << 4) |
+                ((int) Math.Round(MathHelper.Clamp(z, 0, 1) * 15.0f) & 0x0F));
+        }
+
+        /// <summary>
+        /// Creates a new instance of Bgra4444.
+        /// </summary>
+        /// <param name="x">The x component</param>
+        /// <param name="y">The y component</param>
+        /// <param name="z">The z component</param>
+        /// <param name="w">The w component</param>
+        public Bgra4444(float x, float y, float z, float w)
+        {
+            _packedValue = Pack(x, y, z, w);
+        }
+
+        /// <summary>
+        /// Creates a new instance of Bgra4444.
+        /// </summary>
+        /// <param name="vector">Vector containing the components for the packed vector.</param>
+        public Bgra4444(Vector4 vector)
+        {
+            _packedValue = Pack(vector.X, vector.Y, vector.Z, vector.W);
+        }
+
+        /// <summary>
+        /// Gets and sets the packed value.
+        /// </summary>
+        [CLSCompliant(false)]
+        public UInt16 PackedValue
+        {
+            get
+            {
+                return _packedValue;
+            }
+            set
+            {
+                _packedValue = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the packed vector in Vector4 format.
+        /// </summary>
+        /// <returns>The packed vector in Vector4 format</returns>
+        public Vector4 ToVector4()
+        {
+            const float maxVal = 1 / 15.0f;
+
+            return new Vector4( ((_packedValue >> 8) & 0x0F) * maxVal,
+                                ((_packedValue >> 4) & 0x0F) * maxVal,
+                                (_packedValue & 0x0F) * maxVal,
+                                ((_packedValue >> 12) & 0x0F) * maxVal);
+        }
+
+        /// <summary>
+        /// Sets the packed vector from a Vector4.
+        /// </summary>
+        /// <param name="vector">Vector containing the components.</param>
+        void IPackedVector.PackFromVector4(Vector4 vector)
+        {
+            _packedValue = Pack(vector.X, vector.Y, vector.Z, vector.W);
+        }
+
+        /// <summary>
+        /// Compares an object with the packed vector.
+        /// </summary>
+        /// <param name="obj">The object to compare.</param>
+        /// <returns>true if the object is equal to the packed vector.</returns>
+        public override bool Equals(object obj)
+        {
+            if (obj != null && (obj is Bgra4444))
+                return this == (Bgra4444)obj;
+            return false;
+        }
+
+        /// <summary>
+        /// Compares another Bgra4444 packed vector with the packed vector.
+        /// </summary>
+        /// <param name="other">The Bgra4444 packed vector to compare.</param>
+        /// <returns>true if the packed vectors are equal.</returns>
+        public bool Equals(Bgra4444 other)
+        {
+            return _packedValue == other._packedValue;
+        }
+
+        /// <summary>
+        /// Gets a string representation of the packed vector.
+        /// </summary>
+        /// <returns>A string representation of the packed vector.</returns>
+        public override string ToString()
+        {
+            return ToVector4().ToString();
+        }
+
+        /// <summary>
+        /// Gets a hash code of the packed vector.
+        /// </summary>
+        /// <returns>The hash code for the packed vector.</returns>
+        public override int GetHashCode()
+        {
+            return _packedValue.GetHashCode();
+        }
+
+        public static bool operator ==(Bgra4444 lhs, Bgra4444 rhs)
+        {
+            return lhs._packedValue == rhs._packedValue;
+        }
+
+        public static bool operator !=(Bgra4444 lhs, Bgra4444 rhs)
+        {
+            return lhs._packedValue != rhs._packedValue;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/Bgra5551.cs b/MonoGame.Framework/Graphics/PackedVector/Bgra5551.cs
new file mode 100644
index 00000000000..9a3e828f1ee
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/Bgra5551.cs
@@ -0,0 +1,137 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    /// <summary>
+    /// Packed vector type containing unsigned normalized values ranging from 0 to 1.
+    /// The x , y and z components use 5 bits, and the w component uses 1 bit.
+    /// </summary>
+    public struct Bgra5551 : IPackedVector<UInt16>, IEquatable<Bgra5551>, IPackedVector
+    {
+        /// <summary>
+        /// Gets and sets the packed value.
+        /// </summary>
+        [CLSCompliant(false)]
+        public UInt16 PackedValue
+        {
+            get
+            {
+                return packedValue;
+            }
+            set
+            {
+                packedValue = value;
+            }
+        }
+
+        private UInt16 packedValue;
+
+        /// <summary>
+        /// Creates a new instance of Bgra5551.
+        /// </summary>
+        /// <param name="x">The x component</param>
+        /// <param name="y">The y component</param>
+        /// <param name="z">The z component</param>
+        /// <param name="w">The w component</param>
+        public Bgra5551(float x, float y, float z, float w)
+        {
+            packedValue = Pack(x, y, z, w);
+        }
+
+        /// <summary>
+        /// Creates a new instance of Bgra5551.
+        /// </summary>
+        /// <param name="vector">
+        /// Vector containing the components for the packed vector.
+        /// </param>
+        public Bgra5551(Vector4 vector)
+        {
+            packedValue = Pack(vector.X, vector.Y, vector.Z, vector.W);
+        }
+
+        /// <summary>
+        /// Gets the packed vector in Vector4 format.
+        /// </summary>
+        /// <returns>The packed vector in Vector4 format</returns>
+        public Vector4 ToVector4()
+        {
+            return new Vector4(
+                (float) (((packedValue >> 10) & 0x1F) / 31.0f),
+                (float) (((packedValue >> 5) & 0x1F) / 31.0f),
+                (float) (((packedValue >> 0) & 0x1F) / 31.0f),
+                (float) ((packedValue >> 15)& 0x01)
+            );
+        }
+
+        /// <summary>
+        /// Sets the packed vector from a Vector4.
+        /// </summary>
+        /// <param name="vector">Vector containing the components.</param>
+        void IPackedVector.PackFromVector4(Vector4 vector)
+        {
+            packedValue = Pack(vector.X, vector.Y, vector.Z, vector.W);
+        }
+
+        /// <summary>
+        /// Compares an object with the packed vector.
+        /// </summary>
+        /// <param name="obj">The object to compare.</param>
+        /// <returns>True if the object is equal to the packed vector.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is Bgra5551) && Equals((Bgra5551) obj);
+        }
+
+        /// <summary>
+        /// Compares another Bgra5551 packed vector with the packed vector.
+        /// </summary>
+        /// <param name="other">The Bgra5551 packed vector to compare.</param>
+        /// <returns>True if the packed vectors are equal.</returns>
+        public bool Equals(Bgra5551 other)
+        {
+            return packedValue == other.packedValue;
+        }
+
+        /// <summary>
+        /// Gets a string representation of the packed vector.
+        /// </summary>
+        /// <returns>A string representation of the packed vector.</returns>
+        public override string ToString()
+        {
+            return ToVector4().ToString();
+        }
+
+        /// <summary>
+        /// Gets a hash code of the packed vector.
+        /// </summary>
+        /// <returns>The hash code for the packed vector.</returns>
+        public override int GetHashCode()
+        {
+            return packedValue.GetHashCode();
+        }
+
+        public static bool operator ==(Bgra5551 lhs, Bgra5551 rhs)
+        {
+            return lhs.packedValue == rhs.packedValue;
+        }
+
+        public static bool operator !=(Bgra5551 lhs, Bgra5551 rhs)
+        {
+            return lhs.packedValue != rhs.packedValue;
+        }
+
+        private static UInt16 Pack(float x, float y, float z, float w)
+        {
+            return (UInt16) (
+                (((int) Math.Round(MathHelper.Clamp(x, 0, 1) * 31.0f) & 0x1F) << 10) |
+                (((int) Math.Round(MathHelper.Clamp(y, 0, 1) * 31.0f) & 0x1F) << 5) |
+                (((int) Math.Round(MathHelper.Clamp(z, 0, 1) * 31.0f) & 0x1F) << 0) |
+                ((((int) Math.Round(MathHelper.Clamp(w, 0, 1)) & 0x1) << 15))
+            );
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/Byte4.cs b/MonoGame.Framework/Graphics/PackedVector/Byte4.cs
new file mode 100644
index 00000000000..934ed8fb1c3
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/Byte4.cs
@@ -0,0 +1,159 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    /// <summary>
+    /// Packed vector type containing four 8-bit unsigned integer values, ranging from 0 to 255.
+    /// </summary>
+    public struct Byte4 : IPackedVector<uint>, IEquatable<Byte4>, IPackedVector
+    {
+        uint packedValue;
+
+        /// <summary>
+        /// Initializes a new instance of the Byte4 class.
+        /// </summary>
+        /// <param name="vector">A vector containing the initial values for the components of the Byte4 structure.</param>
+        public Byte4(Vector4 vector)
+        {
+            packedValue = Pack(ref vector);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the Byte4 class.
+        /// </summary>
+        /// <param name="x">Initial value for the x component.</param>
+        /// <param name="y">Initial value for the y component.</param>
+        /// <param name="z">Initial value for the z component.</param>
+        /// <param name="w">Initial value for the w component.</param>
+        public Byte4(float x, float y, float z, float w)
+        {
+            var vector = new Vector4(x, y, z, w);
+            packedValue = Pack(ref vector);
+        }
+
+        /// <summary>
+        /// Compares the current instance of a class to another instance to determine whether they are different.
+        /// </summary>
+        /// <param name="a">The object to the left of the equality operator.</param>
+        /// <param name="b">The object to the right of the equality operator.</param>
+        /// <returns>true if the objects are different; false otherwise.</returns>
+        public static bool operator !=(Byte4 a, Byte4 b)
+        {
+            return a.PackedValue != b.PackedValue;
+        }
+
+        /// <summary>
+        /// Compares the current instance of a class to another instance to determine whether they are the same.
+        /// </summary>
+        /// <param name="a">The object to the left of the equality operator.</param>
+        /// <param name="b">The object to the right of the equality operator.</param>
+        /// <returns>true if the objects are the same; false otherwise.</returns>
+        public static bool operator ==(Byte4 a, Byte4 b)
+        {
+            return a.PackedValue == b.PackedValue;
+        }
+
+        /// <summary>
+        /// Directly gets or sets the packed representation of the value.
+        /// </summary>
+        /// <value>The packed representation of the value.</value>
+        [CLSCompliant(false)]
+        public uint PackedValue
+        {
+            get
+            {
+                return packedValue;
+            }
+            set
+            {
+                packedValue = value;
+            }
+        }
+
+        /// <summary>
+        /// Returns a value that indicates whether the current instance is equal to a specified object.
+        /// </summary>
+        /// <param name="obj">The object with which to make the comparison.</param>
+        /// <returns>true if the current instance is equal to the specified object; false otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            if (obj is Byte4)
+                return this == (Byte4)obj;
+            return false;
+        }
+
+        /// <summary>
+        /// Returns a value that indicates whether the current instance is equal to a specified object.
+        /// </summary>
+        /// <param name="other">The object with which to make the comparison.</param>
+        /// <returns>true if the current instance is equal to the specified object; false otherwise.</returns>
+        public bool Equals(Byte4 other)
+        {
+            return this == other;
+        }
+
+        /// <summary>
+        /// Gets the hash code for the current instance.
+        /// </summary>
+        /// <returns>Hash code for the instance.</returns>
+        public override int GetHashCode()
+        {
+            return packedValue.GetHashCode();
+        }
+
+        /// <summary>
+        /// Returns a string representation of the current instance.
+        /// </summary>
+        /// <returns>String that represents the object.</returns>
+        public override string ToString()
+        {
+            return packedValue.ToString("x8");
+        }
+
+        /// <summary>
+        /// Packs a vector into a uint.
+        /// </summary>
+        /// <param name="vector">The vector containing the values to pack.</param>
+        /// <returns>The ulong containing the packed values.</returns>
+        static uint Pack(ref Vector4 vector)
+        {
+            const float max = 255.0f;
+            const float min = 0.0f;
+
+            // clamp the value between min and max values
+            var byte4 = (uint) Math.Round(MathHelper.Clamp(vector.X, min, max)) & 0xFF;
+            var byte3 = ((uint) Math.Round(MathHelper.Clamp(vector.Y, min, max)) & 0xFF) << 0x8;
+            var byte2 = ((uint) Math.Round(MathHelper.Clamp(vector.Z, min, max)) & 0xFF) << 0x10;
+            var byte1 = ((uint) Math.Round(MathHelper.Clamp(vector.W, min, max)) & 0xFF) << 0x18;
+
+            return byte4 | byte3 | byte2 | byte1;
+        }
+
+        /// <summary>
+        /// Sets the packed representation from a Vector4.
+        /// </summary>
+        /// <param name="vector">The vector to create the packed representation from.</param>
+        void IPackedVector.PackFromVector4(Vector4 vector)
+        {
+            packedValue = Pack(ref vector);
+        }
+
+        /// <summary>
+        /// Expands the packed representation into a Vector4.
+        /// </summary>
+        /// <returns>The expanded vector.</returns>
+        public Vector4 ToVector4()
+        {
+            return new Vector4(
+                (float)(packedValue & 0xFF),
+                (float)((packedValue >> 0x8) & 0xFF),
+                (float)((packedValue >> 0x10) & 0xFF),
+                (float)((packedValue >> 0x18) & 0xFF));
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/PackedVector/HalfSingle.cs b/MonoGame.Framework/Graphics/PackedVector/HalfSingle.cs
new file mode 100644
index 00000000000..25016af57ef
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/HalfSingle.cs
@@ -0,0 +1,81 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    public struct HalfSingle : IPackedVector<UInt16>, IEquatable<HalfSingle>, IPackedVector
+    {
+        UInt16 packedValue;
+
+        public HalfSingle(float single)
+        {
+            packedValue = HalfTypeHelper.Convert(single);
+        }
+
+        [CLSCompliant(false)]
+        public ushort PackedValue
+        {
+            get
+            {
+                return this.packedValue;
+            }
+            set
+            {
+                this.packedValue = value;
+            }
+        }
+
+        public float ToSingle()
+        {
+            return HalfTypeHelper.Convert(this.packedValue);
+        }
+
+        void IPackedVector.PackFromVector4(Vector4 vector)
+        {
+            this.packedValue = HalfTypeHelper.Convert(vector.X);
+        }
+
+        Vector4 IPackedVector.ToVector4()
+        {
+            return new Vector4(this.ToSingle(), 0f, 0f, 1f);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj != null && obj.GetType() == this.GetType())
+            {
+                return this == (HalfSingle)obj;
+            }
+
+            return false;
+        }
+
+        public bool Equals(HalfSingle other)
+        {
+            return this.packedValue == other.packedValue;
+        }
+
+        public override string ToString()
+        {
+            return this.ToSingle().ToString();
+        }
+
+        public override int GetHashCode()
+        {
+            return this.packedValue.GetHashCode();
+        }
+
+        public static bool operator ==(HalfSingle lhs, HalfSingle rhs)
+        {
+            return lhs.packedValue == rhs.packedValue;
+        }
+
+        public static bool operator !=(HalfSingle lhs, HalfSingle rhs)
+        {
+            return lhs.packedValue != rhs.packedValue;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/HalfTypeHelper.cs b/MonoGame.Framework/Graphics/PackedVector/HalfTypeHelper.cs
new file mode 100644
index 00000000000..81c2d5351c1
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/HalfTypeHelper.cs
@@ -0,0 +1,117 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    internal class HalfTypeHelper
+    {
+        [StructLayout(LayoutKind.Explicit)]
+        private struct uif
+        {
+            [FieldOffset(0)]
+            public float f;
+            [FieldOffset(0)]
+            public int i;
+            [FieldOffset(0)]
+            public uint u;
+        }
+
+        internal static UInt16 Convert(float f)
+        {
+            uif uif = new uif();
+            uif.f = f;
+            return Convert(uif.i);
+        }
+
+        internal static UInt16 Convert(int i)
+        {
+            int s = (i >> 16) & 0x00008000;
+            int e = ((i >> 23) & 0x000000ff) - (127 - 15);
+            int m = i & 0x007fffff;
+
+            if (e <= 0)
+            {
+                if (e < -10)
+                {
+                    return (UInt16)s;
+                }
+
+                m = m | 0x00800000;
+
+                int t = 14 - e;
+                int a = (1 << (t - 1)) - 1;
+                int b = (m >> t) & 1;
+
+                m = (m + a + b) >> t;
+
+                return (UInt16)(s | m);
+            }
+            else if (e == 0xff - (127 - 15))
+            {
+                if (m == 0)
+                {
+                    return (UInt16)(s | 0x7c00);
+                }
+                else
+                {
+                    m >>= 13;
+                    return (UInt16)(s | 0x7c00 | m | ((m == 0) ? 1 : 0));
+                }
+            }
+            else
+            {
+                m = m + 0x00000fff + ((m >> 13) & 1);
+
+                if ((m & 0x00800000) != 0)
+                {
+                    m = 0;
+                    e += 1;
+                }
+
+                if (e > 30)
+                {
+                    return (UInt16)(s | 0x7c00);
+                }
+
+                return (UInt16)(s | (e << 10) | (m >> 13));
+            }
+        }
+
+        internal static float Convert(ushort value)
+        {
+            uint rst;
+            uint mantissa = (uint)(value & 1023);
+            uint exp = 0xfffffff2;
+
+            if ((value & -33792) == 0)
+            {
+                if (mantissa != 0)
+                {
+                    while ((mantissa & 1024) == 0)
+                    {
+                        exp--;
+                        mantissa = mantissa << 1;
+                    }
+                    mantissa &= 0xfffffbff;
+                    rst = ((uint)((((uint)value & 0x8000) << 16) | ((exp + 127) << 23))) | (mantissa << 13);
+                }
+                else
+                {
+                    rst = (uint)((value & 0x8000) << 16);
+                }
+            }
+            else
+            {
+                rst = (uint)(((((uint)value & 0x8000) << 16) | ((((((uint)value >> 10) & 0x1f) - 15) + 127) << 23)) | (mantissa << 13));
+            }
+
+            var uif = new uif();
+            uif.u = rst;
+            return uif.f;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/HalfVector2.cs b/MonoGame.Framework/Graphics/PackedVector/HalfVector2.cs
new file mode 100644
index 00000000000..37eea9feeb1
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/HalfVector2.cs
@@ -0,0 +1,90 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    public struct HalfVector2 : IPackedVector<uint>, IPackedVector, IEquatable<HalfVector2>
+    {
+        private uint packedValue;
+        public HalfVector2(float x, float y)
+        {
+            this.packedValue = PackHelper(x, y);
+        }
+
+        public HalfVector2(Vector2 vector)
+        {
+            this.packedValue = PackHelper(vector.X, vector.Y);
+        }
+
+        void IPackedVector.PackFromVector4(Vector4 vector)
+        {
+            this.packedValue = PackHelper(vector.X, vector.Y);
+        }
+
+        private static uint PackHelper(float vectorX, float vectorY)
+        {
+            uint num2 = HalfTypeHelper.Convert(vectorX);
+            uint num = (uint)(HalfTypeHelper.Convert(vectorY) << 0x10);
+            return (num2 | num);
+        }
+
+        public Vector2 ToVector2()
+        {
+            Vector2 vector;
+            vector.X = HalfTypeHelper.Convert((ushort)this.packedValue);
+            vector.Y = HalfTypeHelper.Convert((ushort)(this.packedValue >> 0x10));
+            return vector;
+        }
+
+        Vector4 IPackedVector.ToVector4()
+        {
+            Vector2 vector = this.ToVector2();
+            return new Vector4(vector.X, vector.Y, 0f, 1f);
+        }
+
+        [CLSCompliant(false)]
+        public uint PackedValue
+        {
+            get
+            {
+                return this.packedValue;
+            }
+            set
+            {
+                this.packedValue = value;
+            }
+        }
+        public override string ToString()
+        {
+            return this.ToVector2().ToString();
+        }
+
+        public override int GetHashCode()
+        {
+            return this.packedValue.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            return ((obj is HalfVector2) && this.Equals((HalfVector2)obj));
+        }
+
+        public bool Equals(HalfVector2 other)
+        {
+            return this.packedValue.Equals(other.packedValue);
+        }
+
+        public static bool operator ==(HalfVector2 a, HalfVector2 b)
+        {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(HalfVector2 a, HalfVector2 b)
+        {
+            return !a.Equals(b);
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/PackedVector/HalfVector4.cs b/MonoGame.Framework/Graphics/PackedVector/HalfVector4.cs
new file mode 100644
index 00000000000..8ae98c43ce9
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/HalfVector4.cs
@@ -0,0 +1,151 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    /// <summary>
+    /// Packed vector type containing four 16-bit floating-point values.
+    /// </summary>
+    public struct HalfVector4 : IPackedVector<ulong>, IPackedVector, IEquatable<HalfVector4>
+    {
+        ulong packedValue;
+
+        /// <summary>
+        /// Initializes a new instance of the HalfVector4 structure.
+        /// </summary>
+        /// <param name="x">Initial value for the x component.</param>
+        /// <param name="y">Initial value for the y component.</param>
+        /// <param name="z">Initial value for the z component.</param>
+        /// <param name="w">Initial value for the q component.</param>
+        public HalfVector4(float x, float y, float z, float w)
+        {
+            var vector = new Vector4(x, y, z, w);
+            packedValue = PackHelper(ref vector);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the HalfVector4 structure.
+        /// </summary>
+        /// <param name="vector">A vector containing the initial values for the components of the HalfVector4 structure.</param>
+        public HalfVector4(Vector4 vector)
+        {
+            packedValue = PackHelper(ref vector);
+        }
+
+        /// <summary>
+        /// Sets the packed representation from a Vector4.
+        /// </summary>
+        /// <param name="vector">The vector to create the packed representation from.</param>
+        void IPackedVector.PackFromVector4(Vector4 vector)
+        {
+            packedValue = PackHelper(ref vector);
+        }
+
+        /// <summary>
+        /// Packs a vector into a ulong.
+        /// </summary>
+        /// <param name="vector">The vector containing the values to pack.</param>
+        /// <returns>The ulong containing the packed values.</returns>
+        static ulong PackHelper(ref Vector4 vector)
+        {
+            ulong num4 = (ulong)HalfTypeHelper.Convert(vector.X);
+            ulong num3 = ((ulong)HalfTypeHelper.Convert(vector.Y) << 0x10);
+            ulong num2 = ((ulong)HalfTypeHelper.Convert(vector.Z) << 0x20);
+            ulong num1 = ((ulong)HalfTypeHelper.Convert(vector.W) << 0x30);
+            return num4 | num3 | num2 | num1;
+        }
+
+        /// <summary>
+        /// Expands the packed representation into a Vector4.
+        /// </summary>
+        /// <returns>The expanded vector.</returns>
+        public Vector4 ToVector4()
+        {
+            return new Vector4(
+                HalfTypeHelper.Convert((ushort)packedValue),
+                HalfTypeHelper.Convert((ushort)(packedValue >> 0x10)),
+                HalfTypeHelper.Convert((ushort)(packedValue >> 0x20)),
+                HalfTypeHelper.Convert((ushort)(packedValue >> 0x30)));
+        }
+
+        /// <summary>
+        /// Directly gets or sets the packed representation of the value.
+        /// </summary>
+        /// <value>The packed representation of the value.</value>
+        [CLSCompliant(false)]
+        public ulong PackedValue
+        {
+            get
+            {
+                return packedValue;
+            }
+            set
+            {
+                packedValue = value;
+            }
+        }
+
+        /// <summary>
+        /// Returns a string representation of the current instance.
+        /// </summary>
+        /// <returns>String that represents the object.</returns>
+        public override string ToString()
+        {
+            return ToVector4().ToString();
+        }
+
+        /// <summary>
+        /// Gets the hash code for the current instance.
+        /// </summary>
+        /// <returns>Hash code for the instance.</returns>
+        public override int GetHashCode()
+        {
+            return packedValue.GetHashCode();
+        }
+
+        /// <summary>
+        /// Returns a value that indicates whether the current instance is equal to a specified object.
+        /// </summary>
+        /// <param name="obj">The object with which to make the comparison.</param>
+        /// <returns>true if the current instance is equal to the specified object; false otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            return ((obj is HalfVector4) && Equals((HalfVector4)obj));
+        }
+
+        /// <summary>
+        /// Returns a value that indicates whether the current instance is equal to a specified object.
+        /// </summary>
+        /// <param name="other">The object with which to make the comparison.</param>
+        /// <returns>true if the current instance is equal to the specified object; false otherwise.</returns>
+        public bool Equals(HalfVector4 other)
+        {
+            return packedValue.Equals(other.packedValue);
+        }
+
+        /// <summary>
+        /// Compares the current instance of a class to another instance to determine whether they are the same.
+        /// </summary>
+        /// <param name="a">The object to the left of the equality operator.</param>
+        /// <param name="b">The object to the right of the equality operator.</param>
+        /// <returns>true if the objects are the same; false otherwise.</returns>
+        public static bool operator ==(HalfVector4 a, HalfVector4 b)
+        {
+            return a.Equals(b);
+        }
+
+        /// <summary>
+        /// Compares the current instance of a class to another instance to determine whether they are different.
+        /// </summary>
+        /// <param name="a">The object to the left of the equality operator.</param>
+        /// <param name="b">The object to the right of the equality operator.</param>
+        /// <returns>true if the objects are different; false otherwise.</returns>
+        public static bool operator !=(HalfVector4 a, HalfVector4 b)
+        {
+            return !a.Equals(b);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/IPackedVector.cs b/MonoGame.Framework/Graphics/PackedVector/IPackedVector.cs
new file mode 100644
index 00000000000..cb08e5a1e76
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/IPackedVector.cs
@@ -0,0 +1,65 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+//
+// Author: Kenneth James Pouncey
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+	// http://msdn.microsoft.com/en-us/library/microsoft.xna.framework.graphics.packedvector.ipackedvector.aspx
+	public interface IPackedVector
+	{
+		void PackFromVector4 (Vector4 vector);
+
+		Vector4 ToVector4 ();
+	}
+	
+	// PackedVector Generic interface
+	// http://msdn.microsoft.com/en-us/library/bb197661.aspx
+	public interface IPackedVector<TPacked> : IPackedVector
+	{
+		TPacked PackedValue { get; set; }
+	}
+
+}
+
+
+
diff --git a/MonoGame.Framework/Graphics/PackedVector/NormalizedByte2.cs b/MonoGame.Framework/Graphics/PackedVector/NormalizedByte2.cs
new file mode 100644
index 00000000000..8102f595c66
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/NormalizedByte2.cs
@@ -0,0 +1,93 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    public struct NormalizedByte2 : IPackedVector<ushort>, IEquatable<NormalizedByte2>
+    {
+        private ushort _packed;
+
+        public NormalizedByte2(Vector2 vector)
+        {
+            _packed = Pack(vector.X, vector.Y);
+        }
+
+        public NormalizedByte2(float x, float y)
+        {
+            _packed = Pack(x, y);
+        }
+
+        public static bool operator !=(NormalizedByte2 a, NormalizedByte2 b)
+        {
+            return a._packed != b._packed;
+        }
+
+        public static bool operator ==(NormalizedByte2 a, NormalizedByte2 b)
+        {
+            return a._packed == b._packed;
+        }
+
+        [CLSCompliant(false)]
+        public ushort PackedValue
+        {
+            get
+            {
+                return _packed;
+            }
+            set
+            {
+                _packed = value;
+            }
+        }
+
+        public override bool Equals(object obj)
+        {
+            return (obj is NormalizedByte2) &&
+                    ((NormalizedByte2)obj)._packed == _packed;
+        }
+
+        public bool Equals(NormalizedByte2 other)
+        {
+            return _packed == other._packed;
+        }
+
+        public override int GetHashCode()
+        {
+            return _packed.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return _packed.ToString("X");
+        }
+
+        private static ushort Pack(float x, float y)
+        {
+            var byte2 = (((ushort) Math.Round(MathHelper.Clamp(x, -1.0f, 1.0f) * 127.0f)) & 0xFF) << 0;
+            var byte1 = (((ushort) Math.Round(MathHelper.Clamp(y, -1.0f, 1.0f) * 127.0f)) & 0xFF) << 8;
+
+            return (ushort)(byte2 | byte1);
+        }
+
+        void IPackedVector.PackFromVector4(Vector4 vector)
+        {
+            _packed = Pack(vector.X, vector.Y);
+        }
+
+        Vector4 IPackedVector.ToVector4()
+        {
+            return new Vector4(ToVector2(), 0.0f, 1.0f);
+        }
+
+        public Vector2 ToVector2()
+        {
+            return new Vector2(
+                ((sbyte) ((_packed >> 0) & 0xFF)) / 127.0f,
+                ((sbyte) ((_packed >> 8) & 0xFF)) / 127.0f);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/NormalizedByte4.cs b/MonoGame.Framework/Graphics/PackedVector/NormalizedByte4.cs
new file mode 100644
index 00000000000..4baec58b929
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/NormalizedByte4.cs
@@ -0,0 +1,92 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    public struct NormalizedByte4 : IPackedVector<uint>, IEquatable<NormalizedByte4>
+    {
+        private uint _packed;
+
+        public NormalizedByte4(Vector4 vector)
+        {
+            _packed = Pack(vector.X, vector.Y, vector.Z, vector.W);
+        }
+
+        public NormalizedByte4(float x, float y, float z, float w)
+        {
+            _packed = Pack(x, y, z, w);
+        }
+
+        public static bool operator !=(NormalizedByte4 a, NormalizedByte4 b)
+        {
+            return a._packed != b._packed;
+        }
+
+        public static bool operator ==(NormalizedByte4 a, NormalizedByte4 b)
+        {
+            return a._packed == b._packed;
+        }
+
+        [CLSCompliant(false)]
+        public uint PackedValue
+        {
+            get
+            {
+                return _packed;
+            }
+            set
+            {
+                _packed = value;
+            }
+        }
+
+        public override bool Equals(object obj)
+        {
+            return  (obj is NormalizedByte4) &&
+                    ((NormalizedByte4)obj)._packed == _packed;
+        }
+
+        public bool Equals(NormalizedByte4 other)
+        {
+            return _packed == other._packed;
+        }
+
+        public override int GetHashCode()
+        {
+            return _packed.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return _packed.ToString("X");
+        }
+
+        private static uint Pack(float x, float y, float z, float w)
+        {
+            var byte4 = (((uint) Math.Round(MathHelper.Clamp(x, -1.0f, 1.0f) * 127.0f)) & 0xff) << 0;
+            var byte3 = (((uint) Math.Round(MathHelper.Clamp(y, -1.0f, 1.0f) * 127.0f)) & 0xff) << 8;
+            var byte2 = (((uint) Math.Round(MathHelper.Clamp(z, -1.0f, 1.0f) * 127.0f)) & 0xff) << 16;
+            var byte1 = (((uint) Math.Round(MathHelper.Clamp(w, -1.0f, 1.0f) * 127.0f)) & 0xff) << 24;
+
+            return byte4 | byte3 | byte2 | byte1;
+        }
+
+        void IPackedVector.PackFromVector4(Vector4 vector)
+        {
+            _packed = Pack(vector.X, vector.Y, vector.Z, vector.W);
+        }
+
+        public Vector4 ToVector4()
+        {
+            return new Vector4(
+                ((sbyte) ((_packed >> 0) & 0xFF)) / 127.0f,
+                ((sbyte) ((_packed >> 8) & 0xFF)) / 127.0f,
+                ((sbyte) ((_packed >> 16) & 0xFF)) / 127.0f,
+                ((sbyte) ((_packed >> 24) & 0xFF)) / 127.0f);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/NormalizedShort2.cs b/MonoGame.Framework/Graphics/PackedVector/NormalizedShort2.cs
new file mode 100644
index 00000000000..5c602eaa49c
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/NormalizedShort2.cs
@@ -0,0 +1,105 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+	public struct NormalizedShort2 : IPackedVector<uint>, IEquatable<NormalizedShort2>
+	{
+		private uint short2Packed;
+
+        public NormalizedShort2(Vector2 vector)
+		{
+            short2Packed = PackInTwo(vector.X, vector.Y);
+		}
+
+        public NormalizedShort2(float x, float y)
+		{
+            short2Packed = PackInTwo(x, y);
+		}
+
+        public static bool operator !=(NormalizedShort2 a, NormalizedShort2 b)
+		{
+			return !a.Equals (b);
+		}
+
+        public static bool operator ==(NormalizedShort2 a, NormalizedShort2 b)
+		{
+			return a.Equals (b);
+		}
+
+        [CLSCompliant(false)]
+        public uint PackedValue
+        {
+            get
+            {
+                return short2Packed;
+            }
+            set
+            {
+                short2Packed = value;
+            }
+		}
+
+		public override bool Equals (object obj)
+		{
+            return (obj is NormalizedShort2) && Equals((NormalizedShort2)obj);
+		}
+
+        public bool Equals(NormalizedShort2 other)
+		{
+            return short2Packed.Equals(other.short2Packed);
+		}
+
+		public override int GetHashCode ()
+		{
+			return short2Packed.GetHashCode();
+		}
+
+		public override string ToString ()
+		{
+            return short2Packed.ToString("X");
+		}
+
+		public Vector2 ToVector2 ()
+		{
+            const float maxVal = 0x7FFF;
+
+			var v2 = new Vector2 ();
+            v2.X = ((short)(short2Packed & 0xFFFF)) / maxVal;
+            v2.Y = (short)(short2Packed >> 0x10) / maxVal;
+			return v2;
+		}
+
+		private static uint PackInTwo (float vectorX, float vectorY)
+		{
+			const float maxPos = 0x7FFF;
+            const float minNeg = -maxPos;
+
+			// clamp the value between min and max values
+            // Round rather than truncate.
+            var word2 = (uint)((int)MathHelper.Clamp((float)Math.Round(vectorX * maxPos), minNeg, maxPos) & 0xFFFF);
+            var word1 = (uint)(((int)MathHelper.Clamp((float)Math.Round(vectorY * maxPos), minNeg, maxPos) & 0xFFFF) << 0x10);
+
+			return (word2 | word1);
+		}
+
+		void IPackedVector.PackFromVector4 (Vector4 vector)
+		{
+            short2Packed = PackInTwo(vector.X, vector.Y);
+		}
+
+		Vector4 IPackedVector.ToVector4 ()
+		{
+            const float maxVal = 0x7FFF;
+
+			var v4 = new Vector4 (0,0,0,1);
+            v4.X = ((short)((short2Packed >> 0x00) & 0xFFFF)) / maxVal;
+            v4.Y = ((short)((short2Packed >> 0x10) & 0xFFFF)) / maxVal;
+			return v4;
+		}
+	}
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/NormalizedShort4.cs b/MonoGame.Framework/Graphics/PackedVector/NormalizedShort4.cs
new file mode 100644
index 00000000000..c8e2c3857bc
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/NormalizedShort4.cs
@@ -0,0 +1,99 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    public struct NormalizedShort4 : IPackedVector<ulong>, IEquatable<NormalizedShort4>
+	{
+		private ulong short4Packed;
+
+        public NormalizedShort4(Vector4 vector)
+		{
+            short4Packed = PackInFour(vector.X, vector.Y, vector.Z, vector.W);
+		}
+
+        public NormalizedShort4(float x, float y, float z, float w)
+		{
+            short4Packed = PackInFour(x, y, z, w);
+		}
+
+        public static bool operator !=(NormalizedShort4 a, NormalizedShort4 b)
+		{
+			return !a.Equals (b);
+		}
+
+        public static bool operator ==(NormalizedShort4 a, NormalizedShort4 b)
+		{
+			return a.Equals (b);
+		}
+
+        [CLSCompliant(false)]
+        public ulong PackedValue
+        {
+            get
+            {
+                return short4Packed;
+            }
+            set
+            {
+                short4Packed = value;
+            }
+		}
+
+        public override bool Equals(object obj)
+        {
+            return (obj is NormalizedShort4) && Equals((NormalizedShort4)obj);
+        }
+
+        public bool Equals(NormalizedShort4 other)
+        {
+            return short4Packed.Equals(other.short4Packed);
+        }
+
+		public override int GetHashCode ()
+		{
+			return short4Packed.GetHashCode();
+		}
+
+		public override string ToString ()
+		{
+            return short4Packed.ToString("X");
+		}
+
+        private static ulong PackInFour(float vectorX, float vectorY, float vectorZ, float vectorW)
+		{
+			const long mask = 0xFFFF;
+            const long maxPos = 0x7FFF;
+            const long minNeg = -maxPos;
+
+			// clamp the value between min and max values
+            var word4 = (ulong)((int)Math.Round(MathHelper.Clamp(vectorX * maxPos, minNeg, maxPos)) & mask);
+            var word3 = (ulong)((int)Math.Round(MathHelper.Clamp(vectorY * maxPos, minNeg, maxPos)) & mask) << 0x10;
+            var word2 = (ulong)((int)Math.Round(MathHelper.Clamp(vectorZ * maxPos, minNeg, maxPos)) & mask) << 0x20;
+            var word1 = (ulong)((int)Math.Round(MathHelper.Clamp(vectorW * maxPos, minNeg, maxPos)) & mask) << 0x30;
+
+			return (word4 | word3 | word2 | word1);
+		}
+
+		void IPackedVector.PackFromVector4 (Vector4 vector)
+		{
+            short4Packed = PackInFour(vector.X, vector.Y, vector.Z, vector.W);
+		}
+
+		public Vector4 ToVector4 ()
+		{
+            const float maxVal = 0x7FFF;
+
+			var v4 = new Vector4 ();
+            v4.X = ((short)((short4Packed >> 0x00) & 0xFFFF)) / maxVal;
+            v4.Y = ((short)((short4Packed >> 0x10) & 0xFFFF)) / maxVal;
+            v4.Z = ((short)((short4Packed >> 0x20) & 0xFFFF)) / maxVal;
+            v4.W = ((short)((short4Packed >> 0x30) & 0xFFFF)) / maxVal;
+			return v4;
+		}
+	}
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/Rg32.cs b/MonoGame.Framework/Graphics/PackedVector/Rg32.cs
new file mode 100644
index 00000000000..b89bb4f21ad
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/Rg32.cs
@@ -0,0 +1,139 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    /// <summary>
+    /// Packed vector type containing two 16-bit unsigned normalized values ranging from 0 to 1.
+    /// </summary>
+    public struct Rg32 : IPackedVector<uint>, IEquatable<Rg32>, IPackedVector
+    {
+        /// <summary>
+        /// Gets and sets the packed value.
+        /// </summary>
+        [CLSCompliant(false)]
+        public uint PackedValue
+        {
+            get
+            {
+                return packedValue;
+            }
+            set
+            {
+                packedValue = value;
+            }
+        }
+
+        private uint packedValue;
+
+        /// <summary>
+        /// Creates a new instance of Rg32.
+        /// </summary>
+        /// <param name="x">The x component</param>
+        /// <param name="y">The y component</param>
+        public Rg32(float x, float y)
+        {
+            packedValue = Pack(x, y);
+        }
+
+        /// <summary>
+        /// Creates a new instance of Rg32.
+        /// </summary>
+        /// <param name="vector">
+        /// Vector containing the components for the packed vector.
+        /// </param>
+        public Rg32(Vector2 vector)
+        {
+            packedValue = Pack(vector.X, vector.Y);
+        }
+
+        /// <summary>
+        /// Gets the packed vector in Vector2 format.
+        /// </summary>
+        /// <returns>The packed vector in Vector2 format</returns>
+        public Vector2 ToVector2()
+        {
+            return new Vector2(
+                (float) ((packedValue & 0xFFFF) / 65535.0f),
+                (float)(((packedValue >> 16) & 0xFFFF) / 65535.0f)
+            );
+        }
+
+        /// <summary>
+        /// Sets the packed vector from a Vector4.
+        /// </summary>
+        /// <param name="vector">Vector containing the components.</param>
+        void IPackedVector.PackFromVector4(Vector4 vector)
+        {
+            packedValue = Pack(vector.X, vector.Y);
+        }
+
+        /// <summary>
+        /// Gets the packed vector in Vector4 format.
+        /// </summary>
+        /// <returns>The packed vector in Vector4 format</returns>
+        Vector4 IPackedVector.ToVector4()
+        {
+            return new Vector4(ToVector2(), 0.0f, 1.0f);
+        }
+
+        /// <summary>
+        /// Compares an object with the packed vector.
+        /// </summary>
+        /// <param name="obj">The object to compare.</param>
+        /// <returns>True if the object is equal to the packed vector.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is Rg32) && Equals((Rg32) obj);
+        }
+
+        /// <summary>
+        /// Compares another Rg32 packed vector with the packed vector.
+        /// </summary>
+        /// <param name="other">The Rg32 packed vector to compare.</param>
+        /// <returns>True if the packed vectors are equal.</returns>
+        public bool Equals(Rg32 other)
+        {
+            return packedValue == other.packedValue;
+        }
+
+        /// <summary>
+        /// Gets a string representation of the packed vector.
+        /// </summary>
+        /// <returns>A string representation of the packed vector.</returns>
+        public override string ToString()
+        {
+            return ToVector2().ToString();
+        }
+
+        /// <summary>
+        /// Gets a hash code of the packed vector.
+        /// </summary>
+        /// <returns>The hash code for the packed vector.</returns>
+        public override int GetHashCode()
+        {
+            return packedValue.GetHashCode();
+        }
+
+        public static bool operator ==(Rg32 lhs, Rg32 rhs)
+        {
+            return lhs.packedValue == rhs.packedValue;
+        }
+
+        public static bool operator !=(Rg32 lhs, Rg32 rhs)
+        {
+            return lhs.packedValue != rhs.packedValue;
+        }
+
+        private static uint Pack(float x, float y)
+        {
+            return (uint) (
+                (((int) Math.Round(MathHelper.Clamp(x, 0, 1) * 65535.0f) & 0xFFFF) ) |
+                (((int) Math.Round(MathHelper.Clamp(y, 0, 1) * 65535.0f) & 0xFFFF) << 16)
+            );
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/Rgba1010102.cs b/MonoGame.Framework/Graphics/PackedVector/Rgba1010102.cs
new file mode 100644
index 00000000000..97e672b2d81
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/Rgba1010102.cs
@@ -0,0 +1,137 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    /// <summary>
+    /// Packed vector type containing unsigned normalized values ranging from 0 to 1.
+    /// The x, y and z components use 10 bits, and the w component uses 2 bits.
+    /// </summary>
+    public struct Rgba1010102 : IPackedVector<uint>, IEquatable<Rgba1010102>, IPackedVector
+    {
+        /// <summary>
+        /// Gets and sets the packed value.
+        /// </summary>
+        [CLSCompliant(false)]
+        public uint PackedValue
+        {
+            get
+            {
+                return packedValue;
+            }
+            set
+            {
+                packedValue = value;
+            }
+        }
+
+        private uint packedValue;
+
+        /// <summary>
+        /// Creates a new instance of Rgba1010102.
+        /// </summary>
+        /// <param name="x">The x component</param>
+        /// <param name="y">The y component</param>
+        /// <param name="z">The z component</param>
+        /// <param name="w">The w component</param>
+        public Rgba1010102(float x, float y, float z, float w)
+        {
+            packedValue = Pack(x, y, z, w);
+        }
+
+        /// <summary>
+        /// Creates a new instance of Rgba1010102.
+        /// </summary>
+        /// <param name="vector">
+        /// Vector containing the components for the packed vector.
+        /// </param>
+        public Rgba1010102(Vector4 vector)
+        {
+            packedValue = Pack(vector.X, vector.Y, vector.Z, vector.W);
+        }
+
+        /// <summary>
+        /// Gets the packed vector in Vector4 format.
+        /// </summary>
+        /// <returns>The packed vector in Vector4 format</returns>
+        public Vector4 ToVector4()
+        {
+            return new Vector4(
+                (float) (((packedValue >> 0) & 0x03FF) / 1023.0f),
+                (float) (((packedValue >> 10) & 0x03FF) / 1023.0f),
+                (float) (((packedValue >> 20) & 0x03FF) / 1023.0f),
+                (float) (((packedValue >> 30) & 0x03) / 3.0f)
+            );
+        }
+
+        /// <summary>
+        /// Sets the packed vector from a Vector4.
+        /// </summary>
+        /// <param name="vector">Vector containing the components.</param>
+        void IPackedVector.PackFromVector4(Vector4 vector)
+        {
+            packedValue = Pack(vector.X, vector.Y, vector.Z, vector.W);
+        }
+
+        /// <summary>
+        /// Compares an object with the packed vector.
+        /// </summary>
+        /// <param name="obj">The object to compare.</param>
+        /// <returns>True if the object is equal to the packed vector.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is Rgba1010102) && Equals((Rgba1010102) obj);
+        }
+
+        /// <summary>
+        /// Compares another Rgba1010102 packed vector with the packed vector.
+        /// </summary>
+        /// <param name="other">The Rgba1010102 packed vector to compare.</param>
+        /// <returns>True if the packed vectors are equal.</returns>
+        public bool Equals(Rgba1010102 other)
+        {
+            return packedValue == other.packedValue;
+        }
+
+        /// <summary>
+        /// Gets a string representation of the packed vector.
+        /// </summary>
+        /// <returns>A string representation of the packed vector.</returns>
+        public override string ToString()
+        {
+            return ToVector4().ToString();
+        }
+
+        /// <summary>
+        /// Gets a hash code of the packed vector.
+        /// </summary>
+        /// <returns>The hash code for the packed vector.</returns>
+        public override int GetHashCode()
+        {
+            return packedValue.GetHashCode();
+        }
+
+        public static bool operator ==(Rgba1010102 lhs, Rgba1010102 rhs)
+        {
+            return lhs.packedValue == rhs.packedValue;
+        }
+
+        public static bool operator !=(Rgba1010102 lhs, Rgba1010102 rhs)
+        {
+            return lhs.packedValue != rhs.packedValue;
+        }
+
+        private static uint Pack(float x, float y, float z, float w)
+        {
+            return (uint) (
+                (((int) Math.Round(MathHelper.Clamp(x, 0, 1) * 1023.0f) & 0x03FF) << 0) |
+                (((int) Math.Round(MathHelper.Clamp(y, 0, 1) * 1023.0f) & 0x03FF) << 10) |
+                (((int) Math.Round(MathHelper.Clamp(z, 0, 1) * 1023.0f) & 0x03FF) << 20) |
+                (((int) Math.Round(MathHelper.Clamp(w, 0, 1) * 3.0f) & 0x03) << 30)
+            );
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/Rgba64.cs b/MonoGame.Framework/Graphics/PackedVector/Rgba64.cs
new file mode 100644
index 00000000000..6ae4a34eba0
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/Rgba64.cs
@@ -0,0 +1,136 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+	/// <summary>
+    /// Packed vector type containing four 16-bit unsigned normalized values ranging from 0 to 1.
+	/// </summary>
+	public struct Rgba64 : IPackedVector<ulong>, IEquatable<Rgba64>, IPackedVector
+	{
+		/// <summary>
+		/// Gets and sets the packed value.
+		/// </summary>
+		[CLSCompliant(false)]
+		public ulong PackedValue
+		{
+			get
+			{
+				return packedValue;
+			}
+			set
+			{
+				packedValue = value;
+			}
+		}
+
+		private ulong packedValue;
+
+		/// <summary>
+		/// Creates a new instance of Rgba64.
+		/// </summary>
+		/// <param name="x">The x component</param>
+		/// <param name="y">The y component</param>
+		/// <param name="z">The z component</param>
+		/// <param name="w">The w component</param>
+		public Rgba64(float x, float y, float z, float w)
+		{
+			packedValue = Pack(x, y, z, w);
+		}
+
+		/// <summary>
+		/// Creates a new instance of Rgba64.
+		/// </summary>
+		/// <param name="vector">
+		/// Vector containing the components for the packed vector.
+		/// </param>
+		public Rgba64(Vector4 vector)
+		{
+			packedValue = Pack(vector.X, vector.Y, vector.Z, vector.W);
+		}
+
+		/// <summary>
+		/// Gets the packed vector in Vector4 format.
+		/// </summary>
+		/// <returns>The packed vector in Vector4 format</returns>
+		public Vector4 ToVector4()
+		{
+			return new Vector4(
+                (float) (((packedValue) & 0xFFFF) / 65535.0f),
+                (float) (((packedValue >> 16) & 0xFFFF) / 65535.0f),
+                (float) (((packedValue >> 32) & 0xFFFF) / 65535.0f),
+                (float) (((packedValue >> 48) & 0xFFFF) / 65535.0f)
+            );
+		}
+
+		/// <summary>
+		/// Sets the packed vector from a Vector4.
+		/// </summary>
+		/// <param name="vector">Vector containing the components.</param>
+		void IPackedVector.PackFromVector4(Vector4 vector)
+		{
+			packedValue = Pack(vector.X, vector.Y, vector.Z, vector.W);
+		}
+
+		/// <summary>
+		/// Compares an object with the packed vector.
+		/// </summary>
+		/// <param name="obj">The object to compare.</param>
+		/// <returns>True if the object is equal to the packed vector.</returns>
+		public override bool Equals(object obj)
+		{
+			return (obj is Rgba64) && Equals((Rgba64) obj);
+		}
+
+		/// <summary>
+		/// Compares another Rgba64 packed vector with the packed vector.
+		/// </summary>
+		/// <param name="other">The Rgba64 packed vector to compare.</param>
+		/// <returns>True if the packed vectors are equal.</returns>
+		public bool Equals(Rgba64 other)
+		{
+			return packedValue == other.packedValue;
+		}
+
+		/// <summary>
+		/// Gets a string representation of the packed vector.
+		/// </summary>
+		/// <returns>A string representation of the packed vector.</returns>
+		public override string ToString()
+		{
+			return ToVector4().ToString();
+		}
+
+		/// <summary>
+		/// Gets a hash code of the packed vector.
+		/// </summary>
+		/// <returns>The hash code for the packed vector.</returns>
+		public override int GetHashCode()
+		{
+			return packedValue.GetHashCode();
+		}
+
+		public static bool operator ==(Rgba64 lhs, Rgba64 rhs)
+		{
+			return lhs.packedValue == rhs.packedValue;
+		}
+
+		public static bool operator !=(Rgba64 lhs, Rgba64 rhs)
+		{
+			return lhs.packedValue != rhs.packedValue;
+		}
+
+		private static ulong Pack(float x, float y, float z, float w)
+		{
+			return (ulong) (
+				(((ulong)Math.Round(MathHelper.Clamp(x * 0xFFFF, 0, 65535f)) ) ) |
+				(((ulong)Math.Round(MathHelper.Clamp(y * 0xFFFF, 0, 65535f)) ) << 16) |
+                (((ulong)Math.Round(MathHelper.Clamp(z * 0xFFFF, 0, 65535f)) ) << 32) |
+				(((ulong)Math.Round(MathHelper.Clamp(w * 0xFFFF, 0, 65535f)) ) << 48)
+            );
+		}
+	}
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/Short2.cs b/MonoGame.Framework/Graphics/PackedVector/Short2.cs
new file mode 100644
index 00000000000..45905bd1a51
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/Short2.cs
@@ -0,0 +1,102 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+	public struct Short2 : IPackedVector<uint>, IEquatable<Short2>
+	{
+		private uint _short2Packed;
+
+		public Short2 (Vector2 vector)
+		{
+			_short2Packed = PackInTwo (vector.X, vector.Y);
+		}
+
+		public Short2 (Single x,Single y)
+		{
+			_short2Packed = PackInTwo (x, y);
+		}
+
+		public static bool operator !=(Short2 a, Short2 b)
+		{
+			return a.PackedValue != b.PackedValue;
+		}
+
+		public static bool operator ==(Short2 a, Short2 b)
+		{
+			return a.PackedValue == b.PackedValue;
+		}
+
+        [CLSCompliant(false)]
+		public uint PackedValue
+        {
+			get
+            {
+				return _short2Packed;
+			}
+			set
+            {
+				_short2Packed = value;
+			}
+		}
+
+		public override bool Equals (object obj)
+		{
+            if (obj is Short2)
+                return this == (Short2)obj;
+            return false;
+		}
+
+		public bool Equals (Short2 other)
+		{
+            return this == other;
+		}
+
+		public override int GetHashCode ()
+		{
+			return _short2Packed.GetHashCode();
+		}
+
+		public override string ToString ()
+		{
+            return _short2Packed.ToString("x8");
+		}
+
+		public Vector2 ToVector2 ()
+		{
+			var v2 = new Vector2 ();
+			v2.X = (short)(_short2Packed & 0xFFFF);
+			v2.Y = (short)(_short2Packed >> 0x10);
+			return v2;
+		}
+
+		private static uint PackInTwo (float vectorX, float vectorY)
+		{
+			const float maxPos = 0x7FFF; // Largest two byte positive number 0xFFFF >> 1;
+			const float minNeg = ~(int)maxPos; // two's complement
+
+            // clamp the value between min and max values
+            var word2 = ((uint) Math.Round(MathHelper.Clamp(vectorX, minNeg, maxPos)) & 0xFFFF);
+            var word1 = (((uint) Math.Round(MathHelper.Clamp(vectorY, minNeg, maxPos)) & 0xFFFF) << 0x10);
+
+            return (word2 | word1);
+		}
+
+		void IPackedVector.PackFromVector4 (Vector4 vector)
+		{
+			_short2Packed = Short2.PackInTwo (vector.X, vector.Y);
+		}
+
+		Vector4 IPackedVector.ToVector4 ()
+		{
+			var v4 = new Vector4 (0,0,0,1);
+			v4.X = (short)(_short2Packed & 0xFFFF);
+			v4.Y = (short)(_short2Packed >> 0x10);
+			return v4;
+		}
+	}
+}
diff --git a/MonoGame.Framework/Graphics/PackedVector/Short4.cs b/MonoGame.Framework/Graphics/PackedVector/Short4.cs
new file mode 100644
index 00000000000..3623870b655
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PackedVector/Short4.cs
@@ -0,0 +1,159 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics.PackedVector
+{
+    /// <summary>
+    /// Packed vector type containing four 16-bit signed integer values.
+    /// </summary>
+    public struct Short4 : IPackedVector<ulong>, IEquatable<Short4>
+    {
+        ulong packedValue;
+
+        /// <summary>
+        /// Initializes a new instance of the Short4 class.
+        /// </summary>
+        /// <param name="vector">A vector containing the initial values for the components of the Short4 structure.</param>
+        public Short4(Vector4 vector)
+        {
+            packedValue = Pack(ref vector);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the Short4 class.
+        /// </summary>
+        /// <param name="x">Initial value for the x component.</param>
+        /// <param name="y">Initial value for the y component.</param>
+        /// <param name="z">Initial value for the z component.</param>
+        /// <param name="w">Initial value for the w component.</param>
+        public Short4(float x, float y, float z, float w)
+        {
+            var vector = new Vector4(x, y, z, w);
+            packedValue = Pack(ref vector);
+        }
+
+        /// <summary>
+        /// Compares the current instance of a class to another instance to determine whether they are different.
+        /// </summary>
+        /// <param name="a">The object to the left of the equality operator.</param>
+        /// <param name="b">The object to the right of the equality operator.</param>
+        /// <returns>true if the objects are different; false otherwise.</returns>
+        public static bool operator !=(Short4 a, Short4 b)
+        {
+            return a.PackedValue != b.PackedValue;
+        }
+
+        /// <summary>
+        /// Compares the current instance of a class to another instance to determine whether they are the same.
+        /// </summary>
+        /// <param name="a">The object to the left of the equality operator.</param>
+        /// <param name="b">The object to the right of the equality operator.</param>
+        /// <returns>true if the objects are the same; false otherwise.</returns>
+        public static bool operator ==(Short4 a, Short4 b)
+        {
+            return a.PackedValue == b.PackedValue;
+        }
+
+        /// <summary>
+        /// Directly gets or sets the packed representation of the value.
+        /// </summary>
+        /// <value>The packed representation of the value.</value>
+        [CLSCompliant(false)]
+        public ulong PackedValue
+        {
+            get
+            {
+                return packedValue;
+            }
+            set
+            {
+                packedValue = value;
+            }
+        }
+
+        /// <summary>
+        /// Returns a value that indicates whether the current instance is equal to a specified object.
+        /// </summary>
+        /// <param name="obj">The object with which to make the comparison.</param>
+        /// <returns>true if the current instance is equal to the specified object; false otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            if (obj is Short4)
+                return this == (Short4)obj;
+            return false;
+        }
+
+        /// <summary>
+        /// Returns a value that indicates whether the current instance is equal to a specified object.
+        /// </summary>
+        /// <param name="other">The object with which to make the comparison.</param>
+        /// <returns>true if the current instance is equal to the specified object; false otherwise.</returns>
+        public bool Equals(Short4 other)
+        {
+            return this == other;
+        }
+
+        /// <summary>
+        /// Gets the hash code for the current instance.
+        /// </summary>
+        /// <returns>Hash code for the instance.</returns>
+        public override int GetHashCode()
+        {
+            return packedValue.GetHashCode();
+        }
+
+        /// <summary>
+        /// Returns a string representation of the current instance.
+        /// </summary>
+        /// <returns>String that represents the object.</returns>
+        public override string ToString()
+        {
+            return packedValue.ToString("x16");
+        }
+
+        /// <summary>
+        /// Packs a vector into a ulong.
+        /// </summary>
+        /// <param name="vector">The vector containing the values to pack.</param>
+        /// <returns>The ulong containing the packed values.</returns>
+        static ulong Pack(ref Vector4 vector)
+        {
+            const long mask = 0xFFFF;
+            const long maxPos = 0x7FFF; // Largest two byte positive number 0xFFFF >> 1;
+			const float minNeg = ~(int)maxPos; // two's complement
+
+            // clamp the value between min and max values
+            var word4 = ((ulong)((int) Math.Round(MathHelper.Clamp(vector.X, minNeg, maxPos))) & mask);
+			var word3 = ((ulong)((int) Math.Round(MathHelper.Clamp(vector.Y, minNeg, maxPos)) & mask)) << 0x10;
+			var word2 = ((ulong)((int) Math.Round(MathHelper.Clamp(vector.Z, minNeg, maxPos)) & mask)) << 0x20;
+			var word1 = ((ulong)((int) Math.Round(MathHelper.Clamp(vector.W, minNeg, maxPos)) & mask)) << 0x30;
+
+            return word4 | word3 | word2 | word1;
+        }
+
+        /// <summary>
+        /// Sets the packed representation from a Vector4.
+        /// </summary>
+        /// <param name="vector">The vector to create the packed representation from.</param>
+        void IPackedVector.PackFromVector4(Vector4 vector)
+        {
+            packedValue = Pack(ref vector);
+        }
+
+        /// <summary>
+        /// Expands the packed representation into a Vector4.
+        /// </summary>
+        /// <returns>The expanded vector.</returns>
+        public Vector4 ToVector4()
+        {
+            return new Vector4(
+                (short)(packedValue & 0xFFFF),
+                (short)((packedValue >> 0x10) & 0xFFFF),
+                (short)((packedValue >> 0x20) & 0xFFFF),
+                (short)((packedValue >> 0x30) & 0xFFFF));
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/PresentInterval.cs b/MonoGame.Framework/Graphics/PresentInterval.cs
new file mode 100644
index 00000000000..aa0b4dd8a0e
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PresentInterval.cs
@@ -0,0 +1,29 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines how <see cref="GraphicsDevice.Present"/> updates the game window.
+    /// </summary>
+    public enum PresentInterval
+    {
+        /// <summary>
+        /// Equivalent to <see cref="PresentInterval.One"/>.
+        /// </summary>
+        Default,
+        /// <summary>
+        /// The driver waits for the vertical retrace period, before updating window client area. Present operations are not affected more frequently than the screen refresh rate.
+        /// </summary>
+        One,
+        /// <summary>
+        /// The driver waits for the vertical retrace period, before updating window client area. Present operations are not affected more frequently than every second screen refresh. 
+        /// </summary>
+        Two,
+        /// <summary>
+        /// The driver updates the window client area immediately. Present operations might be affected immediately. There is no limit for framerate.
+        /// </summary>
+        Immediate,
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/PresentationEventArgs.cs b/MonoGame.Framework/Graphics/PresentationEventArgs.cs
new file mode 100644
index 00000000000..4b9f242daf4
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PresentationEventArgs.cs
@@ -0,0 +1,18 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal class PresentationEventArgs : EventArgs
+    {
+        public PresentationParameters PresentationParameters { get; private set; }
+
+        public PresentationEventArgs(PresentationParameters presentationParameters)
+        {
+            PresentationParameters = presentationParameters;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/PresentationParameters.cs b/MonoGame.Framework/Graphics/PresentationParameters.cs
new file mode 100644
index 00000000000..c1b37d1726e
--- /dev/null
+++ b/MonoGame.Framework/Graphics/PresentationParameters.cs
@@ -0,0 +1,239 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+#if WINDOWS_UAP
+using Windows.UI.Xaml.Controls;
+#endif
+
+#if IOS
+using UIKit;
+using Microsoft.Xna.Framework.Input.Touch;
+#endif
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public class PresentationParameters
+    {
+        #region Constants
+
+        public const int DefaultPresentRate = 60;
+
+        #endregion Constants
+
+        #region Private Fields
+
+        private DepthFormat depthStencilFormat;
+        private SurfaceFormat backBufferFormat;
+        private int backBufferHeight = GraphicsDeviceManager.DefaultBackBufferHeight;
+        private int backBufferWidth = GraphicsDeviceManager.DefaultBackBufferWidth;
+        private IntPtr deviceWindowHandle;
+        private int multiSampleCount;
+        private bool disposed;
+        private bool isFullScreen;
+        private bool hardwareModeSwitch = true;
+
+        #endregion Private Fields
+
+        #region Constructors
+
+        /// <summary>
+        /// Create a <see cref="PresentationParameters"/> instance with default values for all properties.
+        /// </summary>
+        public PresentationParameters()
+        {
+            Clear();
+        }
+
+        #endregion Constructors
+
+        #region Properties
+
+        /// <summary>
+        /// Get or set the format of the back buffer.
+        /// </summary>
+        public SurfaceFormat BackBufferFormat
+        {
+            get { return backBufferFormat; }
+            set { backBufferFormat = value; }
+        }
+
+        /// <summary>
+        /// Get or set the height of the back buffer.
+        /// </summary>
+        public int BackBufferHeight
+        {
+            get { return backBufferHeight; }
+            set { backBufferHeight = value; }
+        }
+
+        /// <summary>
+        /// Get or set the width of the back buffer.
+        /// </summary>
+        public int BackBufferWidth
+        {
+            get { return backBufferWidth; }
+            set { backBufferWidth = value; }
+        }
+
+        /// <summary>
+        /// Get the bounds of the back buffer.
+        /// </summary>
+        public Rectangle Bounds 
+        {
+            get { return new Rectangle(0, 0, backBufferWidth, backBufferHeight); }
+        }
+
+        /// <summary>
+        /// Get or set the handle of the window that will present the back buffer.
+        /// </summary>
+        public IntPtr DeviceWindowHandle
+        {
+            get { return deviceWindowHandle; }
+            set { deviceWindowHandle = value; }
+        }
+
+#if WINDOWS_UAP
+        [CLSCompliant(false)]
+        public SwapChainPanel SwapChainPanel { get; set; }
+#endif
+
+        /// <summary>
+        /// Get or set the depth stencil format for the back buffer.
+        /// </summary>
+		public DepthFormat DepthStencilFormat
+        {
+            get { return depthStencilFormat; }
+            set { depthStencilFormat = value; }
+        }
+
+        /// <summary>
+        /// Get or set a value indicating if we are in full screen mode.
+        /// </summary>
+        public bool IsFullScreen
+        {
+			get
+            {
+				 return isFullScreen;
+            }
+            set
+            {
+                isFullScreen = value;				
+#if IOS && !TVOS
+				UIApplication.SharedApplication.StatusBarHidden = isFullScreen;
+#endif
+
+			}
+        }
+		
+        /// <summary>
+        /// If <code>true</code> the <see cref="GraphicsDevice"/> will do a mode switch
+        /// when going to full screen mode. If <code>false</code> it will instead do a
+        /// soft full screen by maximizing the window and making it borderless.
+        /// </summary>
+        public bool HardwareModeSwitch
+        {
+            get { return hardwareModeSwitch; }
+            set { hardwareModeSwitch = value; }
+        }
+
+        /// <summary>
+        /// Get or set the multisample count for the back buffer.
+        /// </summary>
+        public int MultiSampleCount
+        {
+            get { return multiSampleCount; }
+            set { multiSampleCount = value; }
+        }
+		
+        /// <summary>
+        /// Get or set the presentation interval.
+        /// </summary>
+        public PresentInterval PresentationInterval { get; set; }
+
+        /// <summary>
+        /// Get or set the display orientation.
+        /// </summary>
+		public DisplayOrientation DisplayOrientation 
+		{ 
+			get; 
+			set; 
+		}
+		
+        /// <summary>
+        /// Get or set the RenderTargetUsage for the back buffer.
+        /// Determines if the back buffer is cleared when it is set as the
+        /// render target by the <see cref="GraphicsDevice"/>.
+        /// <see cref="GraphicsDevice"/> target.
+        /// </summary>
+		public RenderTargetUsage RenderTargetUsage { get; set; }
+
+        #endregion Properties
+
+
+        #region Methods
+
+        /// <summary>
+        /// Reset all properties to their default values.
+        /// </summary>
+        public void Clear()
+        {
+            backBufferFormat = SurfaceFormat.Color;
+#if IOS
+			// Mainscreen.Bounds does not account for the device's orientation. it ALWAYS assumes portrait
+			var width = (int)(UIScreen.MainScreen.Bounds.Width * UIScreen.MainScreen.Scale);
+			var height = (int)(UIScreen.MainScreen.Bounds.Height * UIScreen.MainScreen.Scale);
+			
+			// Flip the dimensions if we need to.
+			if (TouchPanel.DisplayOrientation == DisplayOrientation.LandscapeLeft ||
+			    TouchPanel.DisplayOrientation == DisplayOrientation.LandscapeRight)
+			{
+				width = height;
+				height = (int)(UIScreen.MainScreen.Bounds.Width * UIScreen.MainScreen.Scale);
+			}
+			
+			backBufferWidth = width;
+            backBufferHeight = height;
+#else
+            backBufferWidth = GraphicsDeviceManager.DefaultBackBufferWidth;
+            backBufferHeight = GraphicsDeviceManager.DefaultBackBufferHeight;     
+#endif
+            deviceWindowHandle = IntPtr.Zero;
+#if IOS && !TVOS
+			isFullScreen = UIApplication.SharedApplication.StatusBarHidden;
+#else
+            // isFullScreen = false;
+#endif
+            depthStencilFormat = DepthFormat.None;
+            multiSampleCount = 0;
+            PresentationInterval = PresentInterval.Default;
+            DisplayOrientation = Microsoft.Xna.Framework.DisplayOrientation.Default;
+        }
+
+        /// <summary>
+        /// Create a copy of this <see cref="PresentationParameters"/> instance.
+        /// </summary>
+        /// <returns></returns>
+        public PresentationParameters Clone()
+        {
+            PresentationParameters clone = new PresentationParameters();
+            clone.backBufferFormat = this.backBufferFormat;
+            clone.backBufferHeight = this.backBufferHeight;
+            clone.backBufferWidth = this.backBufferWidth;
+            clone.deviceWindowHandle = this.deviceWindowHandle;
+            clone.depthStencilFormat = this.depthStencilFormat;
+            clone.IsFullScreen = this.IsFullScreen;
+            clone.HardwareModeSwitch = this.HardwareModeSwitch;
+            clone.multiSampleCount = this.multiSampleCount;
+            clone.PresentationInterval = this.PresentationInterval;
+            clone.DisplayOrientation = this.DisplayOrientation;
+            clone.RenderTargetUsage = this.RenderTargetUsage;
+            return clone;
+        }
+
+        #endregion Methods
+
+    }
+}
diff --git a/MonoGame.Framework/Graphics/RenderTarget2D.DirectX.cs b/MonoGame.Framework/Graphics/RenderTarget2D.DirectX.cs
new file mode 100644
index 00000000000..eb72011182d
--- /dev/null
+++ b/MonoGame.Framework/Graphics/RenderTarget2D.DirectX.cs
@@ -0,0 +1,203 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using SharpDX.Direct3D11;
+using SharpDX.DXGI;
+using Resource = SharpDX.Direct3D11.Resource;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class RenderTarget2D
+    {
+        internal RenderTargetView[] _renderTargetViews;
+        internal DepthStencilView _depthStencilView;
+        private RenderTarget2D _resolvedTexture;
+
+        private void PlatformConstruct(GraphicsDevice graphicsDevice, int width, int height, bool mipMap,
+            DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage, bool shared)
+        {
+            GenerateIfRequired();
+        }
+
+        private void GenerateIfRequired()
+        {
+            if (_renderTargetViews != null)
+                return;
+
+            // Create a view interface on the rendertarget to use on bind.
+            if (ArraySize > 1)
+            {
+                _renderTargetViews = new RenderTargetView[ArraySize];
+                for (var i = 0; i < ArraySize; i++)
+                {
+                    var renderTargetViewDescription = new RenderTargetViewDescription();
+                    if (GetTextureSampleDescription().Count > 1)
+                    {
+                        renderTargetViewDescription.Dimension = RenderTargetViewDimension.Texture2DMultisampledArray;
+                        renderTargetViewDescription.Texture2DMSArray.ArraySize = 1;
+                        renderTargetViewDescription.Texture2DMSArray.FirstArraySlice = i;
+                    }
+                    else
+                    {
+                        renderTargetViewDescription.Dimension = RenderTargetViewDimension.Texture2DArray;
+                        renderTargetViewDescription.Texture2DArray.ArraySize = 1;
+                        renderTargetViewDescription.Texture2DArray.FirstArraySlice = i;
+                        renderTargetViewDescription.Texture2DArray.MipSlice = 0;
+                    }
+                    _renderTargetViews[i] = new RenderTargetView(
+                        GraphicsDevice._d3dDevice, GetTexture(),
+                        renderTargetViewDescription);
+                }
+            }
+            else
+            {
+                _renderTargetViews = new[] { new RenderTargetView(GraphicsDevice._d3dDevice, GetTexture()) };
+            }
+
+            // If we don't need a depth buffer then we're done.
+            if (DepthStencilFormat == DepthFormat.None)
+                return;
+
+            // The depth stencil view's multisampling configuration must strictly
+            // match the texture's multisampling configuration.  Ignore whatever parameters
+            // were provided and use the texture's configuration so that things are
+            // guarenteed to work.
+            var multisampleDesc = GetTextureSampleDescription();
+
+            // Create a descriptor for the depth/stencil buffer.
+            // Allocate a 2-D surface as the depth/stencil buffer.
+            // Create a DepthStencil view on this surface to use on bind.
+            using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(GraphicsDevice._d3dDevice, new Texture2DDescription
+            {
+                Format = SharpDXHelper.ToFormat(DepthStencilFormat),
+                ArraySize = 1,
+                MipLevels = 1,
+                Width = width,
+                Height = height,
+                SampleDescription = multisampleDesc,
+                BindFlags = BindFlags.DepthStencil,
+            }))
+            {
+                // Create the view for binding to the device.
+                _depthStencilView = new DepthStencilView(GraphicsDevice._d3dDevice, depthBuffer,
+                    new DepthStencilViewDescription()
+                    {
+                        Format = SharpDXHelper.ToFormat(DepthStencilFormat),
+                        Dimension = GetTextureSampleDescription().Count > 1 ? DepthStencilViewDimension.Texture2DMultisampled : DepthStencilViewDimension.Texture2D
+                    });
+            }
+        }
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            if (_renderTargetViews != null)
+            {
+                for (var i = 0; i < _renderTargetViews.Length; i++)
+                    _renderTargetViews[i].Dispose();
+                _renderTargetViews = null;
+            }
+            SharpDX.Utilities.Dispose(ref _depthStencilView);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (_renderTargetViews != null)
+                {
+                    for (var i = 0; i < _renderTargetViews.Length; i++)
+                        _renderTargetViews[i].Dispose();
+                    _renderTargetViews = null;
+                }
+                SharpDX.Utilities.Dispose(ref _depthStencilView);
+                if (_resolvedTexture != null)
+                    SharpDX.Utilities.Dispose(ref _resolvedTexture);
+            }
+
+            base.Dispose(disposing);
+        }
+
+        RenderTargetView IRenderTarget.GetRenderTargetView(int arraySlice)
+        {
+            GenerateIfRequired();
+            return _renderTargetViews[arraySlice];
+        }
+
+        DepthStencilView IRenderTarget.GetDepthStencilView()
+        {
+            GenerateIfRequired();
+            return _depthStencilView;
+        }
+
+        protected internal override SampleDescription CreateSampleDescription()
+        {
+            return this.GraphicsDevice.GetSupportedSampleDescription
+                (SharpDXHelper.ToFormat(this._format), this.MultiSampleCount);
+        }
+
+        internal void ResolveSubresource()
+        {
+            lock (GraphicsDevice._d3dContext)
+            {
+                GraphicsDevice._d3dContext.ResolveSubresource(
+                    this._texture,
+                    0,
+                    _resolvedTexture._texture,
+                    0,
+                    SharpDXHelper.ToFormat(_format));
+            }
+        }
+
+        internal override Resource CreateTexture()
+        {
+            var rt = base.CreateTexture();
+
+            // MSAA RT needs another non-MSAA texture where it is resolved
+            if (SampleDescription.Count > 1)
+            {
+                _resolvedTexture = new RenderTarget2D(
+                    GraphicsDevice,
+                    Width,
+                    Height,
+                    Mipmap,
+                    Format,
+                    DepthStencilFormat,
+                    1,
+                    RenderTargetUsage,
+                    Shared,
+                    ArraySize);
+            }
+
+            return rt;
+        }
+
+        protected override ShaderResourceView CreateShaderResourceView()
+        {
+            if (MultiSampleCount > 1)
+                return new SharpDX.Direct3D11.ShaderResourceView
+                (GraphicsDevice._d3dDevice, _resolvedTexture.GetTexture());
+            else
+                return base.CreateShaderResourceView();
+        }
+
+        protected internal override Texture2DDescription GetTexture2DDescription()
+        {
+            var desc = base.GetTexture2DDescription();
+
+            desc.BindFlags |= BindFlags.RenderTarget;
+            if (desc.SampleDescription.Count > 1)
+                desc.BindFlags &= ~BindFlags.ShaderResource;
+
+            if (Mipmap)
+            {
+                // Note: XNA 4 does not have a method Texture.GenerateMipMaps() 
+                // because generation of mipmaps is not supported on the Xbox 360.
+                // TODO: New method Texture.GenerateMipMaps() required.
+                desc.OptionFlags |= ResourceOptionFlags.GenerateMipMaps;
+            }
+
+            return desc;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/RenderTarget2D.OpenGL.cs b/MonoGame.Framework/Graphics/RenderTarget2D.OpenGL.cs
new file mode 100644
index 00000000000..8bde6d59f57
--- /dev/null
+++ b/MonoGame.Framework/Graphics/RenderTarget2D.OpenGL.cs
@@ -0,0 +1,63 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using MonoGame.OpenGL;
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class RenderTarget2D
+    {
+        int IRenderTarget.GLTexture
+        {
+            get { return glTexture; }
+        }
+
+        TextureTarget IRenderTarget.GLTarget
+        {
+            get { return glTarget; }
+        }
+
+        int IRenderTarget.GLColorBuffer { get; set; }
+        int IRenderTarget.GLDepthBuffer { get; set; }
+        int IRenderTarget.GLStencilBuffer { get; set; }
+
+        TextureTarget IRenderTarget.GetFramebufferTarget(RenderTargetBinding renderTargetBinding)
+        {
+            return glTarget;
+        }
+
+        private void PlatformConstruct(GraphicsDevice graphicsDevice, int width, int height, bool mipMap,
+            DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage, bool shared)
+        {
+            Threading.BlockOnUIThread(() =>
+            {
+                graphicsDevice.PlatformCreateRenderTarget(this, width, height, mipMap, this.Format, preferredDepthFormat, preferredMultiSampleCount, usage);
+            });
+            
+            
+        }
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                if (GraphicsDevice != null)
+                {
+                    Threading.BlockOnUIThread(() =>
+                    {
+                        this.GraphicsDevice.PlatformDeleteRenderTarget(this);
+                    });
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/RenderTarget2D.Web.cs b/MonoGame.Framework/Graphics/RenderTarget2D.Web.cs
new file mode 100644
index 00000000000..89b075325e3
--- /dev/null
+++ b/MonoGame.Framework/Graphics/RenderTarget2D.Web.cs
@@ -0,0 +1,36 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class RenderTarget2D
+    {
+        private void PlatformConstruct(
+            GraphicsDevice graphicsDevice, 
+            int width, 
+            int height, 
+            bool mipMap,
+            DepthFormat preferredDepthFormat,
+            int preferredMultiSampleCount,
+            RenderTargetUsage usage, 
+            bool shared)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            throw new NotImplementedException();
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            throw new NotImplementedException();
+
+            base.Dispose(disposing);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/RenderTarget2D.cs b/MonoGame.Framework/Graphics/RenderTarget2D.cs
new file mode 100644
index 00000000000..a7349de99f3
--- /dev/null
+++ b/MonoGame.Framework/Graphics/RenderTarget2D.cs
@@ -0,0 +1,94 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public partial class RenderTarget2D : Texture2D, IRenderTarget
+	{
+		public DepthFormat DepthStencilFormat { get; private set; }
+		
+		public int MultiSampleCount { get; private set; }
+		
+		public RenderTargetUsage RenderTargetUsage { get; private set; }
+		
+		public bool IsContentLost { get { return false; } }
+		
+		public event EventHandler<EventArgs> ContentLost;
+		
+        private bool SuppressEventHandlerWarningsUntilEventsAreProperlyImplemented()
+        {
+            return ContentLost != null;
+        }
+
+	    public RenderTarget2D(GraphicsDevice graphicsDevice, int width, int height, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage, bool shared, int arraySize)
+	        : base(graphicsDevice, width, height, mipMap, QuerySelectedFormat(graphicsDevice, preferredFormat), SurfaceType.RenderTarget, shared, arraySize)
+	    {
+            DepthStencilFormat = preferredDepthFormat;
+            MultiSampleCount = graphicsDevice.GetClampedMultisampleCount(preferredMultiSampleCount);
+            RenderTargetUsage = usage;
+
+            PlatformConstruct(graphicsDevice, width, height, mipMap, preferredDepthFormat, preferredMultiSampleCount, usage, shared);
+	    }
+        
+        protected static SurfaceFormat QuerySelectedFormat(GraphicsDevice graphicsDevice, SurfaceFormat preferredFormat)
+        {
+			SurfaceFormat selectedFormat = preferredFormat;
+			DepthFormat selectedDepthFormat;
+			int selectedMultiSampleCount;
+
+            if (graphicsDevice != null)
+            {
+                graphicsDevice.Adapter.QueryRenderTargetFormat(graphicsDevice.GraphicsProfile, preferredFormat, DepthFormat.None, 0,
+                    out selectedFormat, out selectedDepthFormat, out selectedMultiSampleCount);
+            }
+            
+            return selectedFormat;
+        }
+
+        public RenderTarget2D (GraphicsDevice graphicsDevice, int width, int height, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage, bool shared)
+			: this(graphicsDevice, width, height, mipMap, preferredFormat, preferredDepthFormat, preferredMultiSampleCount, usage, shared, 1)
+        {
+			
+        }
+
+		public RenderTarget2D (GraphicsDevice graphicsDevice, int width, int height, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
+			:this (graphicsDevice, width, height, mipMap, preferredFormat, preferredDepthFormat, preferredMultiSampleCount, usage, false)
+        {}
+
+		public RenderTarget2D(GraphicsDevice graphicsDevice, int width, int height, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat)
+			:this (graphicsDevice, width, height, mipMap, preferredFormat, preferredDepthFormat, 0, RenderTargetUsage.DiscardContents) 
+		{}
+		
+		public RenderTarget2D(GraphicsDevice graphicsDevice, int width, int height)
+			: this(graphicsDevice, width, height, false, SurfaceFormat.Color, DepthFormat.None, 0, RenderTargetUsage.DiscardContents) 
+		{}
+
+        /// <summary>
+        /// Allows child class to specify the surface type, eg: a swap chain.
+        /// </summary>        
+        protected RenderTarget2D(GraphicsDevice graphicsDevice,
+                        int width,
+                        int height,
+                        bool mipMap,
+                        SurfaceFormat format,
+                        DepthFormat depthFormat,
+                        int preferredMultiSampleCount,
+                        RenderTargetUsage usage,
+                        SurfaceType surfaceType)
+            : base(graphicsDevice, width, height, mipMap, format, surfaceType)
+        {
+            DepthStencilFormat = depthFormat;
+            MultiSampleCount = preferredMultiSampleCount;
+            RenderTargetUsage = usage;
+		}
+
+        protected internal override void GraphicsDeviceResetting()
+        {
+            PlatformGraphicsDeviceResetting();
+            base.GraphicsDeviceResetting();
+        }        
+	}
+}
diff --git a/MonoGame.Framework/Graphics/RenderTarget3D.DirectX.cs b/MonoGame.Framework/Graphics/RenderTarget3D.DirectX.cs
new file mode 100644
index 00000000000..649a39495c9
--- /dev/null
+++ b/MonoGame.Framework/Graphics/RenderTarget3D.DirectX.cs
@@ -0,0 +1,101 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using SharpDX.Direct3D11;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class RenderTarget3D
+    {
+        private int _currentSlice;
+        private RenderTargetView _renderTargetView;
+        private DepthStencilView _depthStencilView;
+
+        private void PlatformConstruct(GraphicsDevice graphicsDevice, int width, int height, bool mipMap,
+            DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
+        {
+            // Setup the multisampling description.
+            var multisampleDesc = new SharpDX.DXGI.SampleDescription(1, 0);
+            if (preferredMultiSampleCount > 1)
+            {
+                multisampleDesc.Count = preferredMultiSampleCount;
+                multisampleDesc.Quality = (int)StandardMultisampleQualityLevels.StandardMultisamplePattern;
+            }
+
+            // Create a descriptor for the depth/stencil buffer.
+            // Allocate a 2-D surface as the depth/stencil buffer.
+            // Create a DepthStencil view on this surface to use on bind.
+            using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(graphicsDevice._d3dDevice, new Texture2DDescription
+            {
+                Format = SharpDXHelper.ToFormat(preferredDepthFormat),
+                ArraySize = 1,
+                MipLevels = 1,
+                Width = width,
+                Height = height,
+                SampleDescription = multisampleDesc,
+                BindFlags = BindFlags.DepthStencil,
+            }))
+            {
+                // Create the view for binding to the device.
+                _depthStencilView = new DepthStencilView(graphicsDevice._d3dDevice, depthBuffer, new DepthStencilViewDescription()
+                {
+                    Format = SharpDXHelper.ToFormat(preferredDepthFormat),
+                    Dimension = DepthStencilViewDimension.Texture2D
+                });
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                SharpDX.Utilities.Dispose(ref _renderTargetView);
+                SharpDX.Utilities.Dispose(ref _depthStencilView);
+            }
+
+            base.Dispose(disposing);
+        }
+
+	    RenderTargetView IRenderTarget.GetRenderTargetView(int arraySlice)
+	    {
+            if (arraySlice >= Depth)
+                throw new ArgumentOutOfRangeException("The arraySlice is out of range for this Texture3D.");
+
+            // Dispose the previous target.
+	        if (_currentSlice != arraySlice && _renderTargetView != null)
+	        {
+	            _renderTargetView.Dispose();
+	            _renderTargetView = null;
+	        }
+
+            // Create the new target view interface.
+	        if (_renderTargetView == null)
+	        {
+	            _currentSlice = arraySlice;
+
+	            var desc = new RenderTargetViewDescription
+	            {
+	                Format = SharpDXHelper.ToFormat(_format),
+	                Dimension = RenderTargetViewDimension.Texture3D,
+	                Texture3D =
+	                    {
+	                        DepthSliceCount = -1,
+	                        FirstDepthSlice = arraySlice,
+	                        MipSlice = 0,
+	                    }
+	            };
+
+	            _renderTargetView = new RenderTargetView(GraphicsDevice._d3dDevice, GetTexture(), desc);
+	        }
+
+	        return _renderTargetView;
+	    }
+
+	    DepthStencilView IRenderTarget.GetDepthStencilView()
+	    {
+	        return _depthStencilView;
+	    }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/RenderTarget3D.cs b/MonoGame.Framework/Graphics/RenderTarget3D.cs
new file mode 100644
index 00000000000..c227a5a2d7b
--- /dev/null
+++ b/MonoGame.Framework/Graphics/RenderTarget3D.cs
@@ -0,0 +1,63 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public partial class RenderTarget3D : Texture3D, IRenderTarget
+	{
+		public DepthFormat DepthStencilFormat { get; private set; }
+		
+		public int MultiSampleCount { get; private set; }
+		
+		public RenderTargetUsage RenderTargetUsage { get; private set; }
+		
+		public bool IsContentLost { get { return false; } }
+		
+		public event EventHandler<EventArgs> ContentLost;
+
+        private bool SuppressEventHandlerWarningsUntilEventsAreProperlyImplemented()
+        {
+            return ContentLost != null;
+        }
+
+		public RenderTarget3D(GraphicsDevice graphicsDevice, int width, int height, int depth, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
+			:base (graphicsDevice, width, height, depth, mipMap, QuerySelectedFormat(graphicsDevice, preferredFormat), true)
+		{
+			DepthStencilFormat = preferredDepthFormat;
+			MultiSampleCount = preferredMultiSampleCount;
+			RenderTargetUsage = usage;
+
+            // If we don't need a depth buffer then we're done.
+            if (preferredDepthFormat == DepthFormat.None)
+                return;
+
+            PlatformConstruct(graphicsDevice, width, height, mipMap, preferredDepthFormat, preferredMultiSampleCount, usage);
+        }
+
+        protected static SurfaceFormat QuerySelectedFormat(GraphicsDevice graphicsDevice, SurfaceFormat preferredFormat)
+        {
+			SurfaceFormat selectedFormat = preferredFormat;
+			DepthFormat selectedDepthFormat;
+			int selectedMultiSampleCount;
+
+            if (graphicsDevice != null)
+            {
+                graphicsDevice.Adapter.QueryRenderTargetFormat(graphicsDevice.GraphicsProfile, preferredFormat, DepthFormat.None, 0, 
+                   out selectedFormat, out selectedDepthFormat, out selectedMultiSampleCount);
+            }
+            
+            return selectedFormat;
+        }
+
+		public RenderTarget3D(GraphicsDevice graphicsDevice, int width, int height, int depth, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat)
+			:this (graphicsDevice, width, height, depth, mipMap, preferredFormat, preferredDepthFormat, 0, RenderTargetUsage.DiscardContents) 
+		{}
+		
+		public RenderTarget3D(GraphicsDevice graphicsDevice, int width, int height, int depth)
+			: this(graphicsDevice, width, height, depth, false, SurfaceFormat.Color, DepthFormat.None, 0, RenderTargetUsage.DiscardContents) 
+		{}
+	}
+}
diff --git a/MonoGame.Framework/Graphics/RenderTargetBinding.cs b/MonoGame.Framework/Graphics/RenderTargetBinding.cs
new file mode 100644
index 00000000000..f1ec91dfbaa
--- /dev/null
+++ b/MonoGame.Framework/Graphics/RenderTargetBinding.cs
@@ -0,0 +1,145 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+//
+// Author: Kenneth James Pouncey
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	// http://msdn.microsoft.com/en-us/library/ff434403.aspx
+	public struct RenderTargetBinding
+	{
+        private readonly Texture _renderTarget;
+        private readonly int _arraySlice;
+        private DepthFormat _depthFormat;
+
+		public Texture RenderTarget 
+        {
+			get { return _renderTarget; }
+		}
+
+        public int ArraySlice
+        {
+            get { return _arraySlice; }
+        }
+
+        internal DepthFormat DepthFormat
+        {
+            get { return _depthFormat; }
+        }
+
+		public RenderTargetBinding(RenderTarget2D renderTarget)
+		{
+			if (renderTarget == null) 
+				throw new ArgumentNullException("renderTarget");
+
+			_renderTarget = renderTarget;
+            _arraySlice = (int)CubeMapFace.PositiveX;
+            _depthFormat = renderTarget.DepthStencilFormat;
+		}
+
+        public RenderTargetBinding(RenderTargetCube renderTarget, CubeMapFace cubeMapFace)
+        {
+            if (renderTarget == null)
+                throw new ArgumentNullException("renderTarget");
+            if (cubeMapFace < CubeMapFace.PositiveX || cubeMapFace > CubeMapFace.NegativeZ)
+                throw new ArgumentOutOfRangeException("cubeMapFace");
+
+            _renderTarget = renderTarget;
+            _arraySlice = (int)cubeMapFace;
+            _depthFormat = renderTarget.DepthStencilFormat;
+        }
+
+#if DIRECTX
+
+        public RenderTargetBinding(RenderTarget2D renderTarget, int arraySlice)
+        {
+            if (renderTarget == null)
+                throw new ArgumentNullException("renderTarget");
+            if (arraySlice < 0 || arraySlice >= renderTarget.ArraySize)
+                throw new ArgumentOutOfRangeException("arraySlice");
+            if (!renderTarget.GraphicsDevice.GraphicsCapabilities.SupportsTextureArrays)
+                throw new InvalidOperationException("Texture arrays are not supported on this graphics device");
+
+            _renderTarget = renderTarget;
+            _arraySlice = arraySlice;
+            _depthFormat = renderTarget.DepthStencilFormat;
+        }
+
+        public RenderTargetBinding(RenderTarget3D renderTarget)
+        {
+            if (renderTarget == null)
+                throw new ArgumentNullException("renderTarget");
+
+            _renderTarget = renderTarget;
+            _arraySlice = 0;
+            _depthFormat = renderTarget.DepthStencilFormat;
+        }
+
+        public RenderTargetBinding(RenderTarget3D renderTarget, int arraySlice)
+        {
+            if (renderTarget == null)
+                throw new ArgumentNullException("renderTarget");
+            if (arraySlice < 0 || arraySlice >= renderTarget.Depth)
+                throw new ArgumentOutOfRangeException("arraySlice");
+
+            _renderTarget = renderTarget;
+            _arraySlice = arraySlice;
+            _depthFormat = renderTarget.DepthStencilFormat;
+        }
+
+#endif 
+
+        public static implicit operator RenderTargetBinding(RenderTarget2D renderTarget)
+        {
+            return new RenderTargetBinding(renderTarget);
+        }
+
+#if DIRECTX
+
+        public static implicit operator RenderTargetBinding(RenderTarget3D renderTarget)
+        {
+            return new RenderTargetBinding(renderTarget);
+        }
+
+#endif
+	}
+}
diff --git a/MonoGame.Framework/Graphics/RenderTargetCube.DirectX.cs b/MonoGame.Framework/Graphics/RenderTargetCube.DirectX.cs
new file mode 100644
index 00000000000..39d88b68e1b
--- /dev/null
+++ b/MonoGame.Framework/Graphics/RenderTargetCube.DirectX.cs
@@ -0,0 +1,101 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using SharpDX.DXGI;
+using SharpDX.Direct3D11;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class RenderTargetCube
+    {
+        private RenderTargetView[] _renderTargetViews;
+        private DepthStencilView _depthStencilView;
+
+        private void PlatformConstruct(GraphicsDevice graphicsDevice, bool mipMap, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
+        {
+            // Create one render target view per cube map face.
+            _renderTargetViews = new RenderTargetView[6];
+            for (int i = 0; i < _renderTargetViews.Length; i++)
+            {
+                var renderTargetViewDescription = new RenderTargetViewDescription
+                {
+                    Dimension = RenderTargetViewDimension.Texture2DArray,
+                    Format = SharpDXHelper.ToFormat(this.Format),
+                    Texture2DArray =
+                    {
+                        ArraySize = 1,
+                        FirstArraySlice = i,
+                        MipSlice = 0
+                    }
+                };
+
+                _renderTargetViews[i] = new RenderTargetView(graphicsDevice._d3dDevice, GetTexture(), renderTargetViewDescription);
+            }
+
+            // If we don't need a depth buffer then we're done.
+            if (preferredDepthFormat == DepthFormat.None)
+                return;
+
+            var sampleDescription = new SampleDescription(1, 0);
+            if (preferredMultiSampleCount > 1)
+            {
+                sampleDescription.Count = preferredMultiSampleCount;
+                sampleDescription.Quality = (int)StandardMultisampleQualityLevels.StandardMultisamplePattern;
+            }
+
+            var depthStencilDescription = new Texture2DDescription
+            {
+                Format = SharpDXHelper.ToFormat(preferredDepthFormat),
+                ArraySize = 1,
+                MipLevels = 1,
+                Width = size,
+                Height = size,
+                SampleDescription = sampleDescription,
+                BindFlags = BindFlags.DepthStencil,
+            };
+
+            using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(graphicsDevice._d3dDevice, depthStencilDescription))
+            {
+                var depthStencilViewDescription = new DepthStencilViewDescription
+                {
+                    Dimension = DepthStencilViewDimension.Texture2D,
+                    Format = SharpDXHelper.ToFormat(preferredDepthFormat),
+                };
+                _depthStencilView = new DepthStencilView(graphicsDevice._d3dDevice, depthBuffer, depthStencilViewDescription);
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (_renderTargetViews != null)
+                {
+                    for (var i = 0; i < _renderTargetViews.Length; i++)
+                        _renderTargetViews[i].Dispose();
+
+                    _renderTargetViews = null;
+                    SharpDX.Utilities.Dispose(ref _depthStencilView);
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+
+        /// <inheritdoc/>
+        [CLSCompliant(false)]
+        public RenderTargetView GetRenderTargetView(int arraySlice)
+        {
+            return _renderTargetViews[arraySlice];
+        }
+
+        /// <inheritdoc/>
+        [CLSCompliant(false)]
+        public DepthStencilView GetDepthStencilView()
+        {
+            return _depthStencilView;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/RenderTargetCube.OpenGL.cs b/MonoGame.Framework/Graphics/RenderTargetCube.OpenGL.cs
new file mode 100644
index 00000000000..9cd5ff17eb2
--- /dev/null
+++ b/MonoGame.Framework/Graphics/RenderTargetCube.OpenGL.cs
@@ -0,0 +1,54 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class RenderTargetCube
+    {
+        int IRenderTarget.GLTexture
+        {
+            get { return glTexture; }
+        }
+
+        TextureTarget IRenderTarget.GLTarget
+        {
+            get { return glTarget; }
+        }
+
+        int IRenderTarget.GLColorBuffer { get; set; }
+        int IRenderTarget.GLDepthBuffer { get; set; }
+        int IRenderTarget.GLStencilBuffer { get; set; }
+
+        TextureTarget IRenderTarget.GetFramebufferTarget(RenderTargetBinding renderTargetBinding)
+        {
+            return TextureTarget.TextureCubeMapPositiveX + renderTargetBinding.ArraySlice;
+        }
+
+        private void PlatformConstruct(GraphicsDevice graphicsDevice, bool mipMap, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
+        {
+            Threading.BlockOnUIThread(() =>
+            {
+                graphicsDevice.PlatformCreateRenderTarget(this, size, size, mipMap, this.Format, preferredDepthFormat, preferredMultiSampleCount, usage);
+            });
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                if (GraphicsDevice != null)
+                {
+                    Threading.BlockOnUIThread(() =>
+                    {
+                        this.GraphicsDevice.PlatformDeleteRenderTarget(this);
+                    });
+                }
+            }
+
+            base.Dispose(disposing);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/RenderTargetCube.Web.cs b/MonoGame.Framework/Graphics/RenderTargetCube.Web.cs
new file mode 100644
index 00000000000..ad32ab47307
--- /dev/null
+++ b/MonoGame.Framework/Graphics/RenderTargetCube.Web.cs
@@ -0,0 +1,23 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class RenderTargetCube
+    {
+        private void PlatformConstruct(GraphicsDevice graphicsDevice, bool mipMap, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            throw new NotImplementedException();
+
+            base.Dispose(disposing);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/RenderTargetCube.cs b/MonoGame.Framework/Graphics/RenderTargetCube.cs
new file mode 100644
index 00000000000..a3f208b6791
--- /dev/null
+++ b/MonoGame.Framework/Graphics/RenderTargetCube.cs
@@ -0,0 +1,95 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Represents a texture cube that can be used as a render target.
+    /// </summary>
+    public partial class RenderTargetCube : TextureCube, IRenderTarget
+    {
+        /// <summary>
+        /// Gets the depth-stencil buffer format of this render target.
+        /// </summary>
+        /// <value>The format of the depth-stencil buffer.</value>
+        public DepthFormat DepthStencilFormat { get; private set; }
+
+        /// <summary>
+        /// Gets the number of multisample locations.
+        /// </summary>
+        /// <value>The number of multisample locations.</value>
+        public int MultiSampleCount { get; private set; }
+
+        /// <summary>
+        /// Gets the usage mode of this render target.
+        /// </summary>
+        /// <value>The usage mode of the render target.</value>
+        public RenderTargetUsage RenderTargetUsage { get; private set; }
+
+        /// <inheritdoc/>
+        int IRenderTarget.Width
+        {
+            get { return size; }
+        }
+
+        /// <inheritdoc/>
+        int IRenderTarget.Height
+        {
+            get { return size; }
+        }
+
+		public bool IsContentLost { get { return false; } }
+		public event EventHandler<EventArgs> ContentLost;
+		
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RenderTargetCube"/> class.
+        /// </summary>
+        /// <param name="graphicsDevice">The graphics device.</param>
+        /// <param name="size">The width and height of a texture cube face in pixels.</param>
+        /// <param name="mipMap"><see langword="true"/> to generate a full mipmap chain; otherwise <see langword="false"/>.</param>
+        /// <param name="preferredFormat">The preferred format of the surface.</param>
+        /// <param name="preferredDepthFormat">The preferred format of the depth-stencil buffer.</param>
+        public RenderTargetCube(GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat)
+            : this(graphicsDevice, size, mipMap, preferredFormat, preferredDepthFormat, 0, RenderTargetUsage.DiscardContents)
+        {            
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RenderTargetCube"/> class.
+        /// </summary>
+        /// <param name="graphicsDevice">The graphics device.</param>
+        /// <param name="size">The width and height of a texture cube face in pixels.</param>
+        /// <param name="mipMap"><see langword="true"/> to generate a full mipmap chain; otherwise <see langword="false"/>.</param>
+        /// <param name="preferredFormat">The preferred format of the surface.</param>
+        /// <param name="preferredDepthFormat">The preferred format of the depth-stencil buffer.</param>
+        /// <param name="preferredMultiSampleCount">The preferred number of multisample locations.</param>
+        /// <param name="usage">The usage mode of the render target.</param>
+        public RenderTargetCube(GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
+            : base(graphicsDevice, size, mipMap, QuerySelectedFormat(graphicsDevice, preferredFormat), true)
+        {
+            DepthStencilFormat = preferredDepthFormat;
+            MultiSampleCount = preferredMultiSampleCount;
+            RenderTargetUsage = usage;
+
+            PlatformConstruct(graphicsDevice, mipMap, preferredDepthFormat, preferredMultiSampleCount, usage);
+        }
+        
+        protected static SurfaceFormat QuerySelectedFormat(GraphicsDevice graphicsDevice, SurfaceFormat preferredFormat)
+        {
+			SurfaceFormat selectedFormat = preferredFormat;
+			DepthFormat selectedDepthFormat;
+			int selectedMultiSampleCount;
+
+            if (graphicsDevice != null)
+            {
+                graphicsDevice.Adapter.QueryRenderTargetFormat(graphicsDevice.GraphicsProfile, preferredFormat, DepthFormat.None, 0, 
+                    out selectedFormat, out selectedDepthFormat, out selectedMultiSampleCount);
+            }
+            
+            return selectedFormat;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/RenderTargetUsage.cs b/MonoGame.Framework/Graphics/RenderTargetUsage.cs
new file mode 100644
index 00000000000..b7334fbc7f8
--- /dev/null
+++ b/MonoGame.Framework/Graphics/RenderTargetUsage.cs
@@ -0,0 +1,26 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines if the previous content in a render target is preserved when it set on the graphics device.
+    /// </summary>
+    public enum RenderTargetUsage
+    {
+        /// <summary>
+        /// The render target content will not be preserved.
+        /// </summary>
+        DiscardContents,
+        /// <summary>
+        /// The render target content will be preserved even if it is slow or requires extra memory.
+        /// </summary>
+        PreserveContents,
+        /// <summary>
+        /// The render target content might be preserved if the platform can do so without a penalty in performance or memory usage.
+        /// </summary>
+        PlatformContents
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/ResourceCreatedEventArgs.cs b/MonoGame.Framework/Graphics/ResourceCreatedEventArgs.cs
new file mode 100644
index 00000000000..4639f0b95d1
--- /dev/null
+++ b/MonoGame.Framework/Graphics/ResourceCreatedEventArgs.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public sealed class ResourceCreatedEventArgs : EventArgs
+    {
+        /// <summary>
+        /// The newly created resource object.
+        /// </summary>
+        public Object Resource { get; internal set; }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/ResourceDestroyedEventArgs.cs b/MonoGame.Framework/Graphics/ResourceDestroyedEventArgs.cs
new file mode 100644
index 00000000000..8444af91f74
--- /dev/null
+++ b/MonoGame.Framework/Graphics/ResourceDestroyedEventArgs.cs
@@ -0,0 +1,17 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public sealed class ResourceDestroyedEventArgs : EventArgs
+    {
+        /// <summary>
+        /// The name of the destroyed resource.
+        /// </summary>
+        public string Name { get; internal set; }
+
+        /// <summary>
+        /// The resource manager tag of the destroyed resource.
+        /// </summary>
+        public Object Tag { get; internal set; }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/SamplerStateCollection.DirectX.cs b/MonoGame.Framework/Graphics/SamplerStateCollection.DirectX.cs
new file mode 100644
index 00000000000..868b9cf7723
--- /dev/null
+++ b/MonoGame.Framework/Graphics/SamplerStateCollection.DirectX.cs
@@ -0,0 +1,66 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+//
+// Author: Kenneth James Pouncey
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public sealed partial class SamplerStateCollection
+    {
+        private int _d3dDirty;
+
+        private void PlatformSetSamplerState(int index)
+        {
+            _d3dDirty |= 1 << index;
+        }
+
+        private void PlatformClear()
+        {
+            _d3dDirty = int.MaxValue;
+        }
+
+        private void PlatformDirty()
+        {
+            _d3dDirty = int.MaxValue;
+        }
+
+        internal void PlatformSetSamplers(GraphicsDevice device)
+        {
+            if (_applyToVertexStage && !device.GraphicsCapabilities.SupportsVertexTextures)
+                return;
+
+            // Skip out if nothing has changed.
+            if (_d3dDirty == 0)
+                return;
+
+            // NOTE: We make the assumption here that the caller has
+            // locked the d3dContext for us to use.
+            SharpDX.Direct3D11.CommonShaderStage shaderStage;
+            if (_applyToVertexStage)
+	            shaderStage = device._d3dContext.VertexShader;
+            else
+	            shaderStage = device._d3dContext.PixelShader;
+
+            for (var i = 0; i < _actualSamplers.Length; i++)
+            {
+                var mask = 1 << i;
+                if ((_d3dDirty & mask) == 0)
+                    continue;
+
+                var sampler = _actualSamplers[i];
+                SharpDX.Direct3D11.SamplerState state = null;
+                if (sampler != null)
+                    state = sampler.GetState(device);
+
+                shaderStage.SetSampler(i, state);
+
+                _d3dDirty &= ~mask;
+                if (_d3dDirty == 0)
+                    break;
+            }
+
+            _d3dDirty = 0;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/SamplerStateCollection.OpenGL.cs b/MonoGame.Framework/Graphics/SamplerStateCollection.OpenGL.cs
new file mode 100644
index 00000000000..d193cdc094c
--- /dev/null
+++ b/MonoGame.Framework/Graphics/SamplerStateCollection.OpenGL.cs
@@ -0,0 +1,52 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+//
+// Author: Kenneth James Pouncey
+
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public sealed partial class SamplerStateCollection
+    {
+        private void PlatformSetSamplerState(int index)
+        {
+        }
+
+        private void PlatformClear()
+        {
+        }
+
+        private void PlatformDirty()
+        {
+        }
+
+        internal void PlatformSetSamplers(GraphicsDevice device)
+        {
+            for (var i = 0; i < _actualSamplers.Length; i++)
+            {
+                var sampler = _actualSamplers[i];
+                var texture = device.Textures[i];
+
+                if (sampler != null && texture != null && sampler != texture.glLastSamplerState)
+                {
+                    // TODO: Avoid doing this redundantly (see TextureCollection.SetTextures())
+                    // However, I suspect that rendering from the same texture with different sampling modes
+                    // is a relatively rare occurrence...
+                    GL.ActiveTexture(TextureUnit.Texture0 + i);
+                    GraphicsExtensions.CheckGLError();
+
+                    // NOTE: We don't have to bind the texture here because it is already bound in
+                    // TextureCollection.SetTextures(). This, of course, assumes that SetTextures() is called
+                    // before this method is called. If that ever changes this code will misbehave.
+                    // GL.BindTexture(texture.glTarget, texture.glTexture);
+                    // GraphicsExtensions.CheckGLError();
+
+                    sampler.Activate(device, texture.glTarget, texture.LevelCount > 1);
+                    texture.glLastSamplerState = sampler;
+                }
+            }
+        }
+	}
+}
diff --git a/MonoGame.Framework/Graphics/SamplerStateCollection.Web.cs b/MonoGame.Framework/Graphics/SamplerStateCollection.Web.cs
new file mode 100644
index 00000000000..b7e8efb68cd
--- /dev/null
+++ b/MonoGame.Framework/Graphics/SamplerStateCollection.Web.cs
@@ -0,0 +1,43 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+//
+// Author: Kenneth James Pouncey
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    using MonoGame.Web;
+
+    public sealed partial class SamplerStateCollection
+    {
+        private void PlatformSetSamplerState(int index)
+        {
+        }
+
+        private void PlatformClear()
+        {
+        }
+
+        private void PlatformDirty()
+        {
+        }
+
+        internal void PlatformSetSamplers(GraphicsDevice device)
+        {
+            for (var i = 0; i < _actualSamplers.Length; i++)
+            {
+                var sampler = _actualSamplers[i];
+                var texture = device.Textures[i];
+
+                if (sampler != null && texture != null && sampler != texture.glLastSamplerState)
+                {
+                    // TODO
+
+                    texture.glLastSamplerState = sampler;
+                }
+            }
+        }
+	}
+}
diff --git a/MonoGame.Framework/Graphics/SamplerStateCollection.cs b/MonoGame.Framework/Graphics/SamplerStateCollection.cs
new file mode 100644
index 00000000000..20826622a6d
--- /dev/null
+++ b/MonoGame.Framework/Graphics/SamplerStateCollection.cs
@@ -0,0 +1,106 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+//
+// Author: Kenneth James Pouncey
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public sealed partial class SamplerStateCollection
+	{
+        private readonly GraphicsDevice _graphicsDevice;
+
+        private readonly SamplerState _samplerStateAnisotropicClamp;
+        private readonly SamplerState _samplerStateAnisotropicWrap;
+        private readonly SamplerState _samplerStateLinearClamp;
+        private readonly SamplerState _samplerStateLinearWrap;
+        private readonly SamplerState _samplerStatePointClamp;
+        private readonly SamplerState _samplerStatePointWrap;
+
+        private readonly SamplerState[] _samplers;
+        private readonly SamplerState[] _actualSamplers;
+        private readonly bool _applyToVertexStage;
+
+		internal SamplerStateCollection(GraphicsDevice device, int maxSamplers, bool applyToVertexStage)
+		{
+		    _graphicsDevice = device;
+
+            _samplerStateAnisotropicClamp = SamplerState.AnisotropicClamp.Clone();
+            _samplerStateAnisotropicWrap = SamplerState.AnisotropicWrap.Clone();
+            _samplerStateLinearClamp = SamplerState.LinearClamp.Clone();
+            _samplerStateLinearWrap = SamplerState.LinearWrap.Clone();
+            _samplerStatePointClamp = SamplerState.PointClamp.Clone();
+            _samplerStatePointWrap = SamplerState.PointWrap.Clone();
+
+            _samplers = new SamplerState[maxSamplers];
+            _actualSamplers = new SamplerState[maxSamplers];
+            _applyToVertexStage = applyToVertexStage;
+
+		    Clear();
+        }
+		
+		public SamplerState this [int index] 
+        {
+			get 
+            { 
+                return _samplers[index]; 
+            }
+
+			set 
+            {
+                if (value == null)
+                    throw new ArgumentNullException("value");
+
+                if (_samplers[index] == value)
+                    return;
+
+                _samplers[index] = value;
+
+                // Static state properties never actually get bound;
+                // instead we use our GraphicsDevice-specific version of them.
+                var newSamplerState = value;
+                if (ReferenceEquals(value, SamplerState.AnisotropicClamp))
+                    newSamplerState = _samplerStateAnisotropicClamp;
+                else if (ReferenceEquals(value, SamplerState.AnisotropicWrap))
+                    newSamplerState = _samplerStateAnisotropicWrap;
+                else if (ReferenceEquals(value, SamplerState.LinearClamp))
+                    newSamplerState = _samplerStateLinearClamp;
+                else if (ReferenceEquals(value, SamplerState.LinearWrap))
+                    newSamplerState = _samplerStateLinearWrap;
+                else if (ReferenceEquals(value, SamplerState.PointClamp))
+                    newSamplerState = _samplerStatePointClamp;
+                else if (ReferenceEquals(value, SamplerState.PointWrap))
+                    newSamplerState = _samplerStatePointWrap;
+
+                newSamplerState.BindToGraphicsDevice(_graphicsDevice);
+
+                _actualSamplers[index] = newSamplerState;
+
+                PlatformSetSamplerState(index);
+            }
+		}
+
+        internal void Clear()
+        {
+            for (var i = 0; i < _samplers.Length; i++)
+            {
+                _samplers[i] = SamplerState.LinearWrap;
+
+                _samplerStateLinearWrap.BindToGraphicsDevice(_graphicsDevice);
+                _actualSamplers[i] = _samplerStateLinearWrap;
+            }
+
+            PlatformClear();
+        }
+
+        /// <summary>
+        /// Mark all the sampler slots as dirty.
+        /// </summary>
+        internal void Dirty()
+        {
+            PlatformDirty();
+        }
+	}
+}
diff --git a/MonoGame.Framework/Graphics/SetDataOptions.cs b/MonoGame.Framework/Graphics/SetDataOptions.cs
new file mode 100644
index 00000000000..a6243083e92
--- /dev/null
+++ b/MonoGame.Framework/Graphics/SetDataOptions.cs
@@ -0,0 +1,25 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines how vertex or index buffer data will be flushed during a SetData operation.
+    /// </summary>
+    public enum SetDataOptions
+    { 
+        /// <summary>
+        /// The SetData can overwrite the portions of existing data.
+        /// </summary>
+        None,
+        /// <summary>
+        /// The SetData will discard the entire buffer. A pointer to a new memory area is returned and rendering from the previous area do not stall.
+        /// </summary>
+        Discard,
+        /// <summary>
+        /// The SetData operation will not overwrite existing data. This allows the driver to return immediately from a SetData operation and continue rendering.
+        /// </summary>
+        NoOverwrite
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/Shader/ConstantBuffer.DirectX.cs b/MonoGame.Framework/Graphics/Shader/ConstantBuffer.DirectX.cs
new file mode 100644
index 00000000000..f6b4b5838fe
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Shader/ConstantBuffer.DirectX.cs
@@ -0,0 +1,60 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal partial class ConstantBuffer : GraphicsResource
+    {
+        private SharpDX.Direct3D11.Buffer _cbuffer;
+
+        private void PlatformInitialize()
+        {
+            // Allocate the hardware constant buffer.
+            var desc = new SharpDX.Direct3D11.BufferDescription();
+            desc.SizeInBytes = _buffer.Length;
+            desc.Usage = SharpDX.Direct3D11.ResourceUsage.Default;
+            desc.BindFlags = SharpDX.Direct3D11.BindFlags.ConstantBuffer;
+            desc.CpuAccessFlags = SharpDX.Direct3D11.CpuAccessFlags.None;
+            lock (GraphicsDevice._d3dContext)
+                _cbuffer = new SharpDX.Direct3D11.Buffer(GraphicsDevice._d3dDevice, desc);
+        }
+
+        private void PlatformClear()
+        {
+            SharpDX.Utilities.Dispose(ref _cbuffer);
+            _dirty = true;
+        }
+
+        internal void PlatformApply(GraphicsDevice device, ShaderStage stage, int slot)
+        {
+            if (_cbuffer == null)
+                PlatformInitialize();
+
+            // NOTE: We make the assumption here that the caller has
+            // locked the d3dContext for us to use.
+            var d3dContext = GraphicsDevice._d3dContext;
+
+            // Update the hardware buffer.
+            if (_dirty)
+            {
+                d3dContext.UpdateSubresource(_buffer, _cbuffer);
+                _dirty = false;
+            }
+            
+            // Set the buffer to the right stage.
+            if (stage == ShaderStage.Vertex)
+                d3dContext.VertexShader.SetConstantBuffer(slot, _cbuffer);
+            else
+                d3dContext.PixelShader.SetConstantBuffer(slot, _cbuffer);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+                SharpDX.Utilities.Dispose(ref _cbuffer);
+            base.Dispose(disposing);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Shader/ConstantBuffer.OpenGL.cs b/MonoGame.Framework/Graphics/Shader/ConstantBuffer.OpenGL.cs
new file mode 100644
index 00000000000..72127c98df5
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Shader/ConstantBuffer.OpenGL.cs
@@ -0,0 +1,85 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal partial class ConstantBuffer
+    {
+        private ShaderProgram _shaderProgram = null;
+        private int _location;
+
+        static ConstantBuffer _lastConstantBufferApplied = null;
+
+        /// <summary>
+        /// A hash value which can be used to compare constant buffers.
+        /// </summary>
+        internal int HashKey { get; private set; }
+
+        private void PlatformInitialize()
+        {
+            var data = new byte[_parameters.Length];
+            for (var i = 0; i < _parameters.Length; i++)
+            {
+                unchecked
+                {
+                    data[i] = (byte)(_parameters[i] | _offsets[i]);
+                }
+            }
+
+            HashKey = MonoGame.Utilities.Hash.ComputeHash(data);
+        }
+
+        private void PlatformClear()
+        {
+            // Force the uniform location to be looked up again
+            _shaderProgram = null;
+        }
+
+        public unsafe void PlatformApply(GraphicsDevice device, ShaderProgram program)
+        {
+            // NOTE: We assume here the program has 
+            // already been set on the device.
+
+            // If the program changed then lookup the
+            // uniform again and apply the state.
+            if (_shaderProgram != program)
+            {
+                var location = program.GetUniformLocation(_name);
+                if (location == -1)
+                    return;
+
+                _shaderProgram = program;
+                _location = location;
+                _dirty = true;
+            }
+
+            // If the shader program is the same, the effect may still be different and have different values in the buffer
+            if (!Object.ReferenceEquals(this, _lastConstantBufferApplied))
+                _dirty = true;
+
+            // If the buffer content hasn't changed then we're
+            // done... use the previously set uniform state.
+            if (!_dirty)
+                return;
+
+            fixed (byte* bytePtr = _buffer)
+            {
+                // TODO: We need to know the type of buffer float/int/bool
+                // and cast this correctly... else it doesn't work as i guess
+                // GL is checking the type of the uniform.
+
+                GL.Uniform4(_location, _buffer.Length / 16, (float*)bytePtr);
+                GraphicsExtensions.CheckGLError();
+            }
+
+            // Clear the dirty flag.
+            _dirty = false;
+
+            _lastConstantBufferApplied = this;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Shader/ConstantBuffer.Web.cs b/MonoGame.Framework/Graphics/Shader/ConstantBuffer.Web.cs
new file mode 100644
index 00000000000..f1337927f8d
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Shader/ConstantBuffer.Web.cs
@@ -0,0 +1,26 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal partial class ConstantBuffer
+    {
+        private void PlatformInitialize()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformClear()
+        {
+            throw new NotImplementedException();
+        }
+
+        public unsafe void PlatformApply(GraphicsDevice device, int program)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Shader/ConstantBuffer.cs b/MonoGame.Framework/Graphics/Shader/ConstantBuffer.cs
new file mode 100644
index 00000000000..a5e765203bc
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Shader/ConstantBuffer.cs
@@ -0,0 +1,181 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal partial class ConstantBuffer : GraphicsResource
+    {
+        private readonly byte[] _buffer;
+
+        private readonly int[] _parameters;
+
+        private readonly int[] _offsets;
+
+        private readonly string _name;
+
+        private ulong _stateKey;
+
+        private bool _dirty;
+        private bool Dirty
+        {
+            get { return _dirty; }
+        }
+
+        public ConstantBuffer(ConstantBuffer cloneSource)
+        {
+            GraphicsDevice = cloneSource.GraphicsDevice;
+
+            // Share the immutable types.
+            _name = cloneSource._name;
+            _parameters = cloneSource._parameters;
+            _offsets = cloneSource._offsets;
+
+            // Clone the mutable types.
+            _buffer = (byte[])cloneSource._buffer.Clone();
+            PlatformInitialize();
+        }
+
+        public ConstantBuffer(GraphicsDevice device,
+                              int sizeInBytes,
+                              int[] parameterIndexes,
+                              int[] parameterOffsets,
+                              string name)
+        {
+            GraphicsDevice = device;
+
+            _buffer = new byte[sizeInBytes];
+
+            _parameters = parameterIndexes;
+            _offsets = parameterOffsets;
+
+            _name = name;
+
+            PlatformInitialize();
+        }
+
+        internal void Clear()
+        {
+            PlatformClear();
+        }
+
+        private void SetData(int offset, int rows, int columns, object data)
+        {
+            // Shader registers are always 4 bytes and all the
+            // incoming data objects should be 4 bytes per element.
+            const int elementSize = 4;
+            const int rowSize = elementSize * 4;
+
+            // Take care of a single element.
+            if (rows == 1 && columns == 1)
+            {
+                // EffectParameter stores all values in arrays by default.             
+                if (data is Array)
+                    Buffer.BlockCopy(data as Array, 0, _buffer, offset, elementSize);
+                else
+                {
+                    // TODO: When we eventually expose the internal Shader 
+                    // API then we will need to deal with non-array elements.
+                    throw new NotImplementedException();
+                }
+            }
+
+
+            // Take care of the single copy case!
+            else if (rows == 1 || (rows == 4 && columns == 4)) {
+                // take care of shader compiler optimization
+                int len = rows * columns * elementSize;
+                if (_buffer.Length - offset > len)
+                len = _buffer.Length - offset;
+                Buffer.BlockCopy(data as Array, 0, _buffer, offset, rows*columns*elementSize);
+            } else
+            {
+                var source = data as Array;
+
+                var stride = (columns*elementSize);
+                for (var y = 0; y < rows; y++)
+                    Buffer.BlockCopy(source, stride*y, _buffer, offset + (rowSize*y), columns*elementSize);
+            }
+        }
+
+        private int SetParameter(int offset, EffectParameter param)
+        {
+            const int elementSize = 4;
+            const int rowSize = elementSize * 4;
+
+            var rowsUsed = 0;
+
+            var elements = param.Elements;
+            if (elements.Count > 0)
+            {
+                for (var i=0; i < elements.Count; i++)
+                {
+                    var rowsUsedSubParam = SetParameter(offset, elements[i]);
+                    offset += rowsUsedSubParam * rowSize;
+                    rowsUsed += rowsUsedSubParam;
+                }
+            }
+            else if (param.Data != null)
+            {
+                switch (param.ParameterType)
+                {
+                    case EffectParameterType.Single:
+                    case EffectParameterType.Int32:
+                    case EffectParameterType.Bool:
+                        // HLSL assumes matrices are column-major, whereas in-memory we use row-major.
+                        // TODO: HLSL can be told to use row-major. We should handle that too.
+                        if (param.ParameterClass == EffectParameterClass.Matrix)
+                        {
+                            rowsUsed = param.ColumnCount;
+                            SetData(offset, param.ColumnCount, param.RowCount, param.Data);
+                        }
+                        else
+                        {
+                            rowsUsed = param.RowCount;
+                            SetData(offset, param.RowCount, param.ColumnCount, param.Data);
+                        }
+                        break;
+                    default:
+                        throw new NotSupportedException("Not supported!");
+                }
+            }
+
+            return rowsUsed;
+        }
+
+        public void Update(EffectParameterCollection parameters)
+        {
+            // TODO:  We should be doing some sort of dirty state 
+            // testing here.
+            //
+            // It should let us skip all parameter updates if
+            // nothing has changed.  It should not be per-parameter
+            // as that is why you should use multiple constant
+            // buffers.
+
+            // If our state key becomes larger than the 
+            // next state key then the keys have rolled 
+            // over and we need to reset.
+            if (_stateKey > EffectParameter.NextStateKey)
+                _stateKey = 0;
+            
+            for (var p = 0; p < _parameters.Length; p++)
+            {
+                var index = _parameters[p];
+                var param = parameters[index];
+
+                if (param.StateKey < _stateKey)
+                    continue;
+
+                var offset = _offsets[p];
+                _dirty = true;
+
+                SetParameter(offset, param);
+            }
+
+            _stateKey = EffectParameter.NextStateKey;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Shader/ConstantBufferCollection.cs b/MonoGame.Framework/Graphics/Shader/ConstantBufferCollection.cs
new file mode 100644
index 00000000000..668bc9dbb38
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Shader/ConstantBufferCollection.cs
@@ -0,0 +1,86 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal sealed class ConstantBufferCollection
+    {
+        private readonly ConstantBuffer[] _buffers;
+
+        private ShaderStage _stage;
+        private ShaderStage Stage { get { return this._stage; } }
+
+        private int _valid;
+
+        internal ConstantBufferCollection(ShaderStage stage, int maxBuffers)
+        {
+            _stage = stage;
+            _buffers = new ConstantBuffer[maxBuffers];
+            _valid = 0;
+        }
+
+        public ConstantBuffer this[int index]
+        {
+            get { return _buffers[index]; }
+            set
+            {
+                if (_buffers[index] == value)
+                    return;
+
+                if (value != null)
+                {
+                    _buffers[index] = value;
+                    _valid |= 1 << index;
+                }
+                else
+                {
+                    _buffers[index] = null;
+                    _valid &= ~(1 << index);
+                }
+            }
+        }
+
+        internal void Clear()
+        {
+            for (var i = 0; i < _buffers.Length; i++)
+                _buffers[i] = null;
+
+            _valid = 0;
+        }
+
+#if WEB
+        internal void SetConstantBuffers(GraphicsDevice device, int shaderProgram)
+#elif OPENGL
+        internal void SetConstantBuffers(GraphicsDevice device, ShaderProgram shaderProgram)
+#else
+        internal void SetConstantBuffers(GraphicsDevice device)
+#endif
+        {
+            // If there are no constant buffers then skip it.
+            if (_valid == 0)
+                return;
+
+            var valid = _valid;
+
+            for (var i = 0; i < _buffers.Length; i++)
+            {
+                var buffer = _buffers[i];
+                if (buffer != null && !buffer.IsDisposed)
+                {
+#if OPENGL || WEB
+                    buffer.PlatformApply(device, shaderProgram);
+#else
+                    buffer.PlatformApply(device, _stage, i);
+#endif
+                }
+
+                // Early out if this is the last one.
+                valid &= ~(1 << i);
+                if (valid == 0)
+                    return;
+            }
+        }
+
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Shader/Shader.DirectX.cs b/MonoGame.Framework/Graphics/Shader/Shader.DirectX.cs
new file mode 100644
index 00000000000..a6d4df29835
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Shader/Shader.DirectX.cs
@@ -0,0 +1,100 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.IO;
+using SharpDX.Direct3D11;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal partial class Shader
+    {
+        private VertexShader _vertexShader;
+        private PixelShader _pixelShader;
+        private byte[] _shaderBytecode;
+
+        // Caches the DirectX input layouts for this vertex shader.
+        private InputLayoutCache _inputLayouts;
+
+        internal byte[] Bytecode
+        {
+            get { return _shaderBytecode; }
+        }
+
+        internal InputLayoutCache InputLayouts
+        {
+            get { return _inputLayouts; }
+        }
+
+        internal VertexShader VertexShader
+        {
+            get
+            {
+                if (_vertexShader == null)
+                    CreateVertexShader();
+                return _vertexShader;
+            }
+        }
+
+        internal PixelShader PixelShader
+        {
+            get
+            {
+                if (_pixelShader == null)
+                    CreatePixelShader();
+                return _pixelShader;
+            }
+        }
+
+        private static int PlatformProfile()
+        {
+            return 1;
+        }
+
+        private void PlatformConstruct(bool isVertexShader, byte[] shaderBytecode)
+        {
+            // We need the bytecode later for allocating the
+            // input layout from the vertex declaration.
+            _shaderBytecode = shaderBytecode;
+
+            HashKey = MonoGame.Utilities.Hash.ComputeHash(Bytecode);
+
+            if (isVertexShader)
+                CreateVertexShader();
+            else
+                CreatePixelShader();
+        }
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            SharpDX.Utilities.Dispose(ref _vertexShader);
+            SharpDX.Utilities.Dispose(ref _pixelShader);
+            SharpDX.Utilities.Dispose(ref _inputLayouts);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                SharpDX.Utilities.Dispose(ref _vertexShader);
+                SharpDX.Utilities.Dispose(ref _pixelShader);
+                SharpDX.Utilities.Dispose(ref _inputLayouts);
+            }
+
+            base.Dispose(disposing);
+        }
+
+        private void CreatePixelShader()
+        {
+            System.Diagnostics.Debug.Assert(Stage == ShaderStage.Pixel);
+            _pixelShader = new PixelShader(GraphicsDevice._d3dDevice, _shaderBytecode);
+        }
+
+        private void CreateVertexShader()
+        {
+            System.Diagnostics.Debug.Assert(Stage == ShaderStage.Vertex);
+            _vertexShader = new VertexShader(GraphicsDevice._d3dDevice, _shaderBytecode, null);
+            _inputLayouts = new InputLayoutCache(GraphicsDevice, Bytecode);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Shader/Shader.OpenGL.cs b/MonoGame.Framework/Graphics/Shader/Shader.OpenGL.cs
new file mode 100644
index 00000000000..315befd6a32
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Shader/Shader.OpenGL.cs
@@ -0,0 +1,116 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Diagnostics;
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal partial class Shader
+    {
+        // The shader handle.
+        private int _shaderHandle = -1;
+
+        // We keep this around for recompiling on context lost and debugging.
+        private string _glslCode;
+
+        private static int PlatformProfile()
+        {
+            return 0;
+        }
+
+        private void PlatformConstruct(bool isVertexShader, byte[] shaderBytecode)
+        {
+            _glslCode = System.Text.Encoding.ASCII.GetString(shaderBytecode);
+
+            HashKey = MonoGame.Utilities.Hash.ComputeHash(shaderBytecode);
+        }
+
+        internal int GetShaderHandle()
+        {
+            // If the shader has already been created then return it.
+            if (_shaderHandle != -1)
+                return _shaderHandle;
+            
+            //
+            _shaderHandle = GL.CreateShader(Stage == ShaderStage.Vertex ? ShaderType.VertexShader : ShaderType.FragmentShader);
+            GraphicsExtensions.CheckGLError();
+            GL.ShaderSource(_shaderHandle, _glslCode);
+            GraphicsExtensions.CheckGLError();
+            GL.CompileShader(_shaderHandle);
+            GraphicsExtensions.CheckGLError();
+            int compiled = 0;
+            GL.GetShader(_shaderHandle, ShaderParameter.CompileStatus, out compiled);
+            GraphicsExtensions.CheckGLError();
+            if (compiled != (int)Bool.True)
+            {
+                var log = GL.GetShaderInfoLog(_shaderHandle);
+                Debug.WriteLine(log);
+
+                GraphicsDevice.DisposeShader(_shaderHandle);
+                _shaderHandle = -1;
+
+                throw new InvalidOperationException("Shader Compilation Failed");
+            }
+
+            return _shaderHandle;
+        }
+
+        internal void GetVertexAttributeLocations(int program)
+        {
+            for (int i = 0; i < Attributes.Length; ++i)
+            {
+                Attributes[i].location = GL.GetAttribLocation(program, Attributes[i].name);
+                GraphicsExtensions.CheckGLError();
+            }
+        }
+
+        internal int GetAttribLocation(VertexElementUsage usage, int index)
+        {
+            for (int i = 0; i < Attributes.Length; ++i)
+            {
+                if ((Attributes[i].usage == usage) && (Attributes[i].index == index))
+                    return Attributes[i].location;
+            }
+            return -1;
+        }
+
+        internal void ApplySamplerTextureUnits(int program)
+        {
+            // Assign the texture unit index to the sampler uniforms.
+            foreach (var sampler in Samplers)
+            {
+                var loc = GL.GetUniformLocation(program, sampler.name);
+                GraphicsExtensions.CheckGLError();
+                if (loc != -1)
+                {
+                    GL.Uniform1(loc, sampler.textureSlot);
+                    GraphicsExtensions.CheckGLError();
+                }
+            }
+        }
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            if (_shaderHandle != -1)
+            {
+                GraphicsDevice.DisposeShader(_shaderHandle);
+                _shaderHandle = -1;
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed && _shaderHandle != -1)
+            {
+                GraphicsDevice.DisposeShader(_shaderHandle);
+                _shaderHandle = -1;
+            }
+
+            base.Dispose(disposing);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Shader/Shader.Web.cs b/MonoGame.Framework/Graphics/Shader/Shader.Web.cs
new file mode 100644
index 00000000000..e725a0dda75
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Shader/Shader.Web.cs
@@ -0,0 +1,27 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal partial class Shader
+    {
+        private static int PlatformProfile()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformConstruct(bool isVertexShader, byte[] shaderBytecode)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Shader/Shader.cs b/MonoGame.Framework/Graphics/Shader/Shader.cs
new file mode 100644
index 00000000000..23dd80f1160
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Shader/Shader.cs
@@ -0,0 +1,125 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+
+    // TODO: We should convert the types below 
+    // into the start of a Shader reflection API.
+
+    internal enum SamplerType
+    {
+        Sampler2D = 0,
+        SamplerCube = 1,
+        SamplerVolume = 2,
+        Sampler1D = 3,
+    }
+
+    internal struct SamplerInfo
+    {
+        public SamplerType type;
+        public int textureSlot;
+        public int samplerSlot;
+        public string name;
+		public SamplerState state;
+
+        // TODO: This should be moved to EffectPass.
+        public int parameter;
+    }
+
+    internal struct VertexAttribute
+    {
+        public VertexElementUsage usage;
+        public int index;
+        public string name;
+        public int location;
+    }
+
+    internal partial class Shader : GraphicsResource
+	{
+        /// <summary>
+        /// Returns the platform specific shader profile identifier.
+        /// </summary>
+        public static int Profile { get { return PlatformProfile(); } }
+
+        /// <summary>
+        /// A hash value which can be used to compare shaders.
+        /// </summary>
+        internal int HashKey { get; private set; }
+
+        public SamplerInfo[] Samplers { get; private set; }
+
+	    public int[] CBuffers { get; private set; }
+
+        public ShaderStage Stage { get; private set; }
+
+        public VertexAttribute[] Attributes { get; private set; }
+
+        internal Shader(GraphicsDevice device, BinaryReader reader)
+        {
+            GraphicsDevice = device;
+
+            var isVertexShader = reader.ReadBoolean();
+            Stage = isVertexShader ? ShaderStage.Vertex : ShaderStage.Pixel;
+
+            var shaderLength = reader.ReadInt32();
+            var shaderBytecode = reader.ReadBytes(shaderLength);
+
+            var samplerCount = (int)reader.ReadByte();
+            Samplers = new SamplerInfo[samplerCount];
+            for (var s = 0; s < samplerCount; s++)
+            {
+                Samplers[s].type = (SamplerType)reader.ReadByte();
+                Samplers[s].textureSlot = reader.ReadByte();
+                Samplers[s].samplerSlot = reader.ReadByte();
+
+				if (reader.ReadBoolean())
+				{
+					Samplers[s].state = new SamplerState();
+					Samplers[s].state.AddressU = (TextureAddressMode)reader.ReadByte();
+					Samplers[s].state.AddressV = (TextureAddressMode)reader.ReadByte();
+					Samplers[s].state.AddressW = (TextureAddressMode)reader.ReadByte();
+                    Samplers[s].state.BorderColor = new Color(
+                        reader.ReadByte(), 
+                        reader.ReadByte(), 
+                        reader.ReadByte(), 
+                        reader.ReadByte());
+					Samplers[s].state.Filter = (TextureFilter)reader.ReadByte();
+					Samplers[s].state.MaxAnisotropy = reader.ReadInt32();
+					Samplers[s].state.MaxMipLevel = reader.ReadInt32();
+					Samplers[s].state.MipMapLevelOfDetailBias = reader.ReadSingle();
+				}
+
+                Samplers[s].name = reader.ReadString();
+                Samplers[s].parameter = reader.ReadByte();
+            }
+
+            var cbufferCount = (int)reader.ReadByte();
+            CBuffers = new int[cbufferCount];
+            for (var c = 0; c < cbufferCount; c++)
+                CBuffers[c] = reader.ReadByte();
+
+            var attributeCount = (int)reader.ReadByte();
+            Attributes = new VertexAttribute[attributeCount];
+            for (var a = 0; a < attributeCount; a++)
+            {
+                Attributes[a].name = reader.ReadString();
+                Attributes[a].usage = (VertexElementUsage)reader.ReadByte();
+                Attributes[a].index = reader.ReadByte();
+                Attributes[a].location = reader.ReadInt16();
+            }
+
+            PlatformConstruct(isVertexShader, shaderBytecode);
+        }
+
+        internal protected override void GraphicsDeviceResetting()
+        {
+            PlatformGraphicsDeviceResetting();
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Shader/ShaderProgramCache.cs b/MonoGame.Framework/Graphics/Shader/ShaderProgramCache.cs
new file mode 100644
index 00000000000..a6c07d47bf1
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Shader/ShaderProgramCache.cs
@@ -0,0 +1,144 @@
+#if OPENGL
+
+using System;
+using System.Collections.Generic;
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+
+    internal class ShaderProgram
+    {
+        public readonly int Program;
+
+        private readonly Dictionary<string, int> _uniformLocations = new Dictionary<string, int>();
+
+        public ShaderProgram(int program)
+        {
+            Program = program;
+        }
+
+        public int GetUniformLocation(string name)
+        {
+            if (_uniformLocations.ContainsKey(name))
+                return _uniformLocations[name];
+
+            var location = GL.GetUniformLocation(Program, name);
+            GraphicsExtensions.CheckGLError();
+            _uniformLocations[name] = location;
+            return location;
+        }
+    }
+
+    /// <summary>
+    /// This class is used to Cache the links between Vertex/Pixel Shaders and Constant Buffers.
+    /// It will be responsible for linking the programs under OpenGL if they have not been linked
+    /// before. If an existing link exists it will be resused.
+    /// </summary>
+    internal class ShaderProgramCache : IDisposable
+    {
+        private readonly Dictionary<int, ShaderProgram> _programCache = new Dictionary<int, ShaderProgram>();
+        GraphicsDevice _graphicsDevice;
+        bool disposed;
+
+        public ShaderProgramCache(GraphicsDevice graphicsDevice)
+        {
+            _graphicsDevice = graphicsDevice;
+        }
+
+        ~ShaderProgramCache()
+        {
+            Dispose(false);
+        }
+
+        /// <summary>
+        /// Clear the program cache releasing all shader programs.
+        /// </summary>
+        public void Clear()
+        {
+            foreach (var pair in _programCache)
+            {
+                _graphicsDevice.DisposeProgram(pair.Value.Program);
+            }
+            _programCache.Clear();
+        }
+
+        public ShaderProgram GetProgram(Shader vertexShader, Shader pixelShader)
+        {
+            // TODO: We should be hashing in the mix of constant 
+            // buffers here as well.  This would allow us to optimize
+            // setting uniforms to only when a constant buffer changes.
+
+            var key = vertexShader.HashKey | pixelShader.HashKey;
+            if (!_programCache.ContainsKey(key))
+            {
+                // the key does not exist so we need to link the programs
+                _programCache.Add(key, Link(vertexShader, pixelShader));
+            }
+
+            return _programCache[key];
+        }
+
+        private ShaderProgram Link(Shader vertexShader, Shader pixelShader)
+        {
+            // NOTE: No need to worry about background threads here
+            // as this is only called at draw time when we're in the
+            // main drawing thread.
+            var program = GL.CreateProgram();
+            GraphicsExtensions.CheckGLError();
+
+            GL.AttachShader(program, vertexShader.GetShaderHandle());
+            GraphicsExtensions.CheckGLError();
+
+            GL.AttachShader(program, pixelShader.GetShaderHandle());
+            GraphicsExtensions.CheckGLError();
+
+            //vertexShader.BindVertexAttributes(program);
+
+            GL.LinkProgram(program);
+            GraphicsExtensions.CheckGLError();
+
+            GL.UseProgram(program);
+            GraphicsExtensions.CheckGLError();
+
+            vertexShader.GetVertexAttributeLocations(program);
+
+            pixelShader.ApplySamplerTextureUnits(program);
+
+            var linked = 0;
+
+            GL.GetProgram(program, GetProgramParameterName.LinkStatus, out linked);
+            GraphicsExtensions.LogGLError("VertexShaderCache.Link(), GL.GetProgram");
+            if (linked == (int)Bool.False)
+            {
+                var log = GL.GetProgramInfoLog(program);
+                Console.WriteLine(log);
+                GL.DetachShader(program, vertexShader.GetShaderHandle());
+                GL.DetachShader(program, pixelShader.GetShaderHandle());
+                _graphicsDevice.DisposeProgram(program);
+                throw new InvalidOperationException("Unable to link effect program");
+            }
+
+            return new ShaderProgram(program);
+        }
+
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposed)
+            {
+                if (disposing)
+                    Clear();
+                disposed = true;
+            }
+        }
+    }
+}
+
+#endif // OPENGL
diff --git a/MonoGame.Framework/Graphics/Shader/ShaderStage.cs b/MonoGame.Framework/Graphics/Shader/ShaderStage.cs
new file mode 100644
index 00000000000..75d8f582885
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Shader/ShaderStage.cs
@@ -0,0 +1,8 @@
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal enum ShaderStage
+    {
+        Vertex,
+        Pixel,
+    }
+}
diff --git a/MonoGame.Framework/Graphics/SpriteBatch.cs b/MonoGame.Framework/Graphics/SpriteBatch.cs
new file mode 100644
index 00000000000..5c1c4c32fe6
--- /dev/null
+++ b/MonoGame.Framework/Graphics/SpriteBatch.cs
@@ -0,0 +1,1198 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Text;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Helper class for drawing text strings and sprites in one or more optimized batches.
+    /// </summary>
+	public class SpriteBatch : GraphicsResource
+	{
+        #region Private Fields
+        readonly SpriteBatcher _batcher;
+
+		SpriteSortMode _sortMode;
+		BlendState _blendState;
+		SamplerState _samplerState;
+		DepthStencilState _depthStencilState; 
+		RasterizerState _rasterizerState;		
+		Effect _effect;
+        bool _beginCalled;
+
+		SpriteEffect _spriteEffect;
+        readonly EffectPass _spritePass;
+
+		Rectangle _tempRect = new Rectangle (0,0,0,0);
+		Vector2 _texCoordTL = new Vector2 (0,0);
+		Vector2 _texCoordBR = new Vector2 (0,0);
+        #endregion
+
+        internal static bool NeedsHalfPixelOffset;
+
+        /// <summary>
+        /// Constructs a <see cref="SpriteBatch"/>.
+        /// </summary>
+        /// <param name="graphicsDevice">The <see cref="GraphicsDevice"/>, which will be used for sprite rendering.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="graphicsDevice"/> is null.</exception>
+        public SpriteBatch (GraphicsDevice graphicsDevice)
+		{
+			if (graphicsDevice == null)
+            {
+				throw new ArgumentNullException ("graphicsDevice", FrameworkResources.ResourceCreationWhenDeviceIsNull);
+			}	
+
+			this.GraphicsDevice = graphicsDevice;
+
+            _spriteEffect = new SpriteEffect(graphicsDevice);
+            _spritePass = _spriteEffect.CurrentTechnique.Passes[0];
+
+            _batcher = new SpriteBatcher(graphicsDevice);
+
+            _beginCalled = false;
+		}
+
+        /// <summary>
+        /// Begins a new sprite and text batch with the specified render state.
+        /// </summary>
+        /// <param name="sortMode">The drawing order for sprite and text drawing. <see cref="SpriteSortMode.Deferred"/> by default.</param>
+        /// <param name="blendState">State of the blending. Uses <see cref="BlendState.AlphaBlend"/> if null.</param>
+        /// <param name="samplerState">State of the sampler. Uses <see cref="SamplerState.LinearClamp"/> if null.</param>
+        /// <param name="depthStencilState">State of the depth-stencil buffer. Uses <see cref="DepthStencilState.None"/> if null.</param>
+        /// <param name="rasterizerState">State of the rasterization. Uses <see cref="RasterizerState.CullCounterClockwise"/> if null.</param>
+        /// <param name="effect">A custom <see cref="Effect"/> to override the default sprite effect. Uses default sprite effect if null.</param>
+        /// <param name="transformMatrix">An optional matrix used to transform the sprite geometry. Uses <see cref="Matrix.Identity"/> if null.</param>
+        /// <exception cref="InvalidOperationException">Thrown if <see cref="Begin"/> is called next time without previous <see cref="End"/>.</exception>
+        /// <remarks>This method uses optional parameters.</remarks>
+        /// <remarks>The <see cref="Begin"/> Begin should be called before drawing commands, and you cannot call it again before subsequent <see cref="End"/>.</remarks>
+        public void Begin
+        (
+             SpriteSortMode sortMode = SpriteSortMode.Deferred,
+             BlendState blendState = null,
+             SamplerState samplerState = null,
+             DepthStencilState depthStencilState = null,
+             RasterizerState rasterizerState = null,
+             Effect effect = null,
+             Matrix? transformMatrix = null
+        )
+        {
+            if (_beginCalled)
+                throw new InvalidOperationException("Begin cannot be called again until End has been successfully called.");
+
+            // defaults
+            _sortMode = sortMode;
+            _blendState = blendState ?? BlendState.AlphaBlend;
+            _samplerState = samplerState ?? SamplerState.LinearClamp;
+            _depthStencilState = depthStencilState ?? DepthStencilState.None;
+            _rasterizerState = rasterizerState ?? RasterizerState.CullCounterClockwise;
+            _effect = effect;
+            _spriteEffect.TransformMatrix = transformMatrix;
+
+            // Setup things now so a user can change them.
+            if (sortMode == SpriteSortMode.Immediate)
+            {
+                Setup();
+            }
+
+            _beginCalled = true;
+        }
+
+        /// <summary>
+        /// Flushes all batched text and sprites to the screen.
+        /// </summary>
+        /// <remarks>This command should be called after <see cref="Begin"/> and drawing commands.</remarks>
+		public void End ()
+		{
+            if (!_beginCalled)
+                throw new InvalidOperationException("Begin must be called before calling End.");
+
+			_beginCalled = false;
+
+			if (_sortMode != SpriteSortMode.Immediate)
+				Setup();
+            
+            _batcher.DrawBatch(_sortMode, _effect);
+        }
+		
+		void Setup() 
+        {
+            var gd = GraphicsDevice;
+			gd.BlendState = _blendState;
+			gd.DepthStencilState = _depthStencilState;
+			gd.RasterizerState = _rasterizerState;
+			gd.SamplerStates[0] = _samplerState;
+
+            _spritePass.Apply();
+		}
+		
+        void CheckValid(Texture2D texture)
+        {
+            if (texture == null)
+                throw new ArgumentNullException("texture");
+            if (!_beginCalled)
+                throw new InvalidOperationException("Draw was called, but Begin has not yet been called. Begin must be called successfully before you can call Draw.");
+        }
+
+        void CheckValid(SpriteFont spriteFont, string text)
+        {
+            if (spriteFont == null)
+                throw new ArgumentNullException("spriteFont");
+            if (text == null)
+                throw new ArgumentNullException("text");
+            if (!_beginCalled)
+                throw new InvalidOperationException("DrawString was called, but Begin has not yet been called. Begin must be called successfully before you can call DrawString.");
+        }
+
+        void CheckValid(SpriteFont spriteFont, StringBuilder text)
+        {
+            if (spriteFont == null)
+                throw new ArgumentNullException("spriteFont");
+            if (text == null)
+                throw new ArgumentNullException("text");
+            if (!_beginCalled)
+                throw new InvalidOperationException("DrawString was called, but Begin has not yet been called. Begin must be called successfully before you can call DrawString.");
+        }
+
+        /// <summary>
+        /// Submit a sprite for drawing in the current batch.
+        /// </summary>
+        /// <param name="texture">A texture.</param>
+        /// <param name="position">The drawing location on screen or null if <paramref name="destinationRectangle"> is used.</paramref></param>
+        /// <param name="destinationRectangle">The drawing bounds on screen or null if <paramref name="position"> is used.</paramref></param>
+        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
+        /// <param name="origin">An optional center of rotation. Uses <see cref="Vector2.Zero"/> if null.</param>
+        /// <param name="rotation">An optional rotation of this sprite. 0 by default.</param>
+        /// <param name="scale">An optional scale vector. Uses <see cref="Vector2.One"/> if null.</param>
+        /// <param name="color">An optional color mask. Uses <see cref="Color.White"/> if null.</param>
+        /// <param name="effects">The optional drawing modificators. <see cref="SpriteEffects.None"/> by default.</param>
+        /// <param name="layerDepth">An optional depth of the layer of this sprite. 0 by default.</param>
+        /// <exception cref="InvalidOperationException">Throwns if both <paramref name="position"/> and <paramref name="destinationRectangle"/> been used.</exception>
+        /// <remarks>This overload uses optional parameters. This overload requires only one of <paramref name="position"/> and <paramref name="destinationRectangle"/> been used.</remarks>
+        [Obsolete("In future versions this method can be removed.")]
+        public void Draw (Texture2D texture,
+                Vector2? position = null,
+                Rectangle? destinationRectangle = null,
+                Rectangle? sourceRectangle = null,
+                Vector2? origin = null,
+                float rotation = 0f,
+                Vector2? scale = null,
+                Color? color = null,
+                SpriteEffects effects = SpriteEffects.None,
+                float layerDepth = 0f)
+        {
+
+            // Assign default values to null parameters here, as they are not compile-time constants
+            if(!color.HasValue)
+                color = Color.White;
+            if(!origin.HasValue)
+                origin = Vector2.Zero;
+            if(!scale.HasValue)
+                scale = Vector2.One;
+
+            // If both drawRectangle and position are null, or if both have been assigned a value, raise an error
+            if((destinationRectangle.HasValue) == (position.HasValue))
+            {
+                throw new InvalidOperationException("Expected drawRectangle or position, but received neither or both.");
+            }
+            else if(position != null)
+            {
+                // Call Draw() using position
+                Draw(texture, (Vector2)position, sourceRectangle, (Color)color, rotation, (Vector2)origin, (Vector2)scale, effects, layerDepth);
+            }
+            else
+            {
+                // Call Draw() using drawRectangle
+                Draw(texture, (Rectangle)destinationRectangle, sourceRectangle, (Color)color, rotation, (Vector2)origin, effects, layerDepth);
+            }
+        }
+
+        /// <summary>
+        /// Submit a sprite for drawing in the current batch.
+        /// </summary>
+        /// <param name="texture">A texture.</param>
+        /// <param name="position">The drawing location on screen.</param>
+        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
+        /// <param name="color">A color mask.</param>
+        /// <param name="rotation">A rotation of this sprite.</param>
+        /// <param name="origin">Center of the rotation. 0,0 by default.</param>
+        /// <param name="scale">A scaling of this sprite.</param>
+        /// <param name="effects">Modificators for drawing. Can be combined.</param>
+        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
+		public void Draw (Texture2D texture,
+				Vector2 position,
+				Rectangle? sourceRectangle,
+				Color color,
+				float rotation,
+				Vector2 origin,
+				Vector2 scale,
+				SpriteEffects effects,
+                float layerDepth)
+		{
+            CheckValid(texture);
+
+            var item = _batcher.CreateBatchItem();
+            item.Texture = texture;
+
+            // set SortKey based on SpriteSortMode.
+            switch ( _sortMode )
+            {
+                // Comparison of Texture objects.
+                case SpriteSortMode.Texture:
+                    item.SortKey = texture.SortingKey;
+                    break;
+                // Comparison of Depth
+                case SpriteSortMode.FrontToBack:
+                    item.SortKey = layerDepth;
+                    break;
+                // Comparison of Depth in reverse
+                case SpriteSortMode.BackToFront:
+                    item.SortKey = -layerDepth;
+                    break;
+            }
+                        
+            origin = origin * scale;
+            
+            float w, h;
+            if (sourceRectangle.HasValue)
+            {
+                var srcRect = sourceRectangle.GetValueOrDefault();
+                w = srcRect.Width * scale.X;
+                h = srcRect.Height * scale.Y;
+                _texCoordTL.X = srcRect.X * texture.TexelWidth;
+                _texCoordTL.Y = srcRect.Y * texture.TexelHeight;
+                _texCoordBR.X = (srcRect.X + srcRect.Width) * texture.TexelWidth;
+                _texCoordBR.Y = (srcRect.Y + srcRect.Height) * texture.TexelHeight;
+            }
+            else
+            {
+                w = texture.Width * scale.X;
+                h = texture.Height * scale.Y;
+                _texCoordTL = Vector2.Zero;
+                _texCoordBR = Vector2.One;
+            }
+            
+            if ((effects & SpriteEffects.FlipVertically) != 0)
+            {
+                var temp = _texCoordBR.Y;
+				_texCoordBR.Y = _texCoordTL.Y;
+				_texCoordTL.Y = temp;
+            }
+            if ((effects & SpriteEffects.FlipHorizontally) != 0)
+            {
+                var temp = _texCoordBR.X;
+				_texCoordBR.X = _texCoordTL.X;
+				_texCoordTL.X = temp;
+            }
+            
+            if (rotation == 0f)
+            {
+                item.Set(position.X - origin.X,
+                        position.Y - origin.Y,
+                        w,
+                        h,
+                        color,
+                        _texCoordTL,
+                        _texCoordBR,
+                        layerDepth);
+            }
+            else
+            {
+                item.Set(position.X,
+                        position.Y,
+                        -origin.X,
+                        -origin.Y,
+                        w,
+                        h,
+                        (float)Math.Sin(rotation),
+                        (float)Math.Cos(rotation),
+                        color,
+                        _texCoordTL,
+                        _texCoordBR,
+                        layerDepth);
+            }
+            
+            FlushIfNeeded();
+		}
+
+        /// <summary>
+        /// Submit a sprite for drawing in the current batch.
+        /// </summary>
+        /// <param name="texture">A texture.</param>
+        /// <param name="position">The drawing location on screen.</param>
+        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
+        /// <param name="color">A color mask.</param>
+        /// <param name="rotation">A rotation of this sprite.</param>
+        /// <param name="origin">Center of the rotation. 0,0 by default.</param>
+        /// <param name="scale">A scaling of this sprite.</param>
+        /// <param name="effects">Modificators for drawing. Can be combined.</param>
+        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
+		public void Draw (Texture2D texture,
+				Vector2 position,
+				Rectangle? sourceRectangle,
+				Color color,
+				float rotation,
+				Vector2 origin,
+				float scale,
+				SpriteEffects effects,
+                float layerDepth)
+		{
+            var scaleVec = new Vector2(scale, scale);
+            Draw(texture, position, sourceRectangle, color, rotation, origin, scaleVec, effects, layerDepth);
+		}
+
+        /// <summary>
+        /// Submit a sprite for drawing in the current batch.
+        /// </summary>
+        /// <param name="texture">A texture.</param>
+        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
+        /// <param name="color">A color mask.</param>
+        /// <param name="rotation">A rotation of this sprite.</param>
+        /// <param name="origin">Center of the rotation. 0,0 by default.</param>
+        /// <param name="effects">Modificators for drawing. Can be combined.</param>
+        /// <param name="layerDepth">A depth of the layer of this sprite.</param>
+		public void Draw (Texture2D texture,
+			Rectangle destinationRectangle,
+			Rectangle? sourceRectangle,
+			Color color,
+			float rotation,
+			Vector2 origin,
+			SpriteEffects effects,
+            float layerDepth)
+		{
+            CheckValid(texture);
+            
+            var item = _batcher.CreateBatchItem();
+            item.Texture = texture;
+
+            // set SortKey based on SpriteSortMode.
+            switch ( _sortMode )
+            {
+                // Comparison of Texture objects.
+                case SpriteSortMode.Texture:
+                    item.SortKey = texture.SortingKey;
+                    break;
+                // Comparison of Depth
+                case SpriteSortMode.FrontToBack:
+                    item.SortKey = layerDepth;
+                    break;
+                // Comparison of Depth in reverse
+                case SpriteSortMode.BackToFront:
+                    item.SortKey = -layerDepth;
+                    break;
+            }
+
+            if (sourceRectangle.HasValue)
+            {
+                var srcRect = sourceRectangle.GetValueOrDefault();
+                _texCoordTL.X = srcRect.X * texture.TexelWidth;
+                _texCoordTL.Y = srcRect.Y * texture.TexelHeight;
+                _texCoordBR.X = (srcRect.X + srcRect.Width) * texture.TexelWidth;
+                _texCoordBR.Y = (srcRect.Y + srcRect.Height) * texture.TexelHeight;
+
+                if(srcRect.Width != 0)
+                    origin.X = origin.X * (float)destinationRectangle.Width / (float)srcRect.Width;
+                else
+                    origin.X = origin.X * (float)destinationRectangle.Width * texture.TexelWidth;
+                if(srcRect.Height != 0)
+                    origin.Y = origin.Y * (float)destinationRectangle.Height / (float)srcRect.Height; 
+                else
+                    origin.Y = origin.Y * (float)destinationRectangle.Height * texture.TexelHeight;
+            }
+            else
+            {
+                _texCoordTL = Vector2.Zero;
+                _texCoordBR = Vector2.One;
+                
+                origin.X = origin.X * (float)destinationRectangle.Width  * texture.TexelWidth;
+                origin.Y = origin.Y * (float)destinationRectangle.Height * texture.TexelHeight;
+            }
+            
+			if ((effects & SpriteEffects.FlipVertically) != 0)
+            {
+                var temp = _texCoordBR.Y;
+				_texCoordBR.Y = _texCoordTL.Y;
+				_texCoordTL.Y = temp;
+			}
+			if ((effects & SpriteEffects.FlipHorizontally) != 0)
+            {
+                var temp = _texCoordBR.X;
+				_texCoordBR.X = _texCoordTL.X;
+				_texCoordTL.X = temp;
+			}
+
+		    if (rotation == 0f)
+		    {
+                item.Set(destinationRectangle.X - origin.X,
+                        destinationRectangle.Y - origin.Y,
+                        destinationRectangle.Width,
+                        destinationRectangle.Height,
+                        color,
+                        _texCoordTL,
+                        _texCoordBR,
+                        layerDepth);
+            }
+            else
+		    {
+                item.Set(destinationRectangle.X,
+                        destinationRectangle.Y,
+                        -origin.X,
+                        -origin.Y,
+                        destinationRectangle.Width,
+                        destinationRectangle.Height,
+                        (float)Math.Sin(rotation),
+                        (float)Math.Cos(rotation),
+                        color,
+                        _texCoordTL,
+                        _texCoordBR,
+                        layerDepth);
+            }
+
+			FlushIfNeeded();
+		}
+
+		// Mark the end of a draw operation for Immediate SpriteSortMode.
+		internal void FlushIfNeeded()
+		{
+			if (_sortMode == SpriteSortMode.Immediate)
+			{
+				_batcher.DrawBatch(_sortMode, _effect);
+			}
+		}
+
+        /// <summary>
+        /// Submit a sprite for drawing in the current batch.
+        /// </summary>
+        /// <param name="texture">A texture.</param>
+        /// <param name="position">The drawing location on screen.</param>
+        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
+        /// <param name="color">A color mask.</param>
+		public void Draw (Texture2D texture, Vector2 position, Rectangle? sourceRectangle, Color color)
+		{
+			CheckValid(texture);
+            
+			var item = _batcher.CreateBatchItem();
+			item.Texture = texture;
+            
+            // set SortKey based on SpriteSortMode.
+            item.SortKey = _sortMode == SpriteSortMode.Texture ? texture.SortingKey : 0;
+
+            Vector2 size;
+
+            if (sourceRectangle.HasValue)
+            {
+                var srcRect = sourceRectangle.GetValueOrDefault();
+                size = new Vector2(srcRect.Width, srcRect.Height);
+                _texCoordTL.X = srcRect.X * texture.TexelWidth;
+                _texCoordTL.Y = srcRect.Y * texture.TexelHeight;
+                _texCoordBR.X = (srcRect.X + srcRect.Width)  * texture.TexelWidth;
+                _texCoordBR.Y = (srcRect.Y + srcRect.Height) * texture.TexelHeight;
+            }
+            else
+            {
+                size = new Vector2(texture.width, texture.height);
+                _texCoordTL = Vector2.Zero;
+                _texCoordBR = Vector2.One;
+            }
+
+            item.Set(position.X,
+                     position.Y,
+                     size.X,
+                     size.Y,
+                     color,
+                     _texCoordTL,
+                     _texCoordBR,
+                     0);
+
+            FlushIfNeeded();
+		}
+
+        /// <summary>
+        /// Submit a sprite for drawing in the current batch.
+        /// </summary>
+        /// <param name="texture">A texture.</param>
+        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+        /// <param name="sourceRectangle">An optional region on the texture which will be rendered. If null - draws full texture.</param>
+        /// <param name="color">A color mask.</param>
+		public void Draw (Texture2D texture, Rectangle destinationRectangle, Rectangle? sourceRectangle, Color color)
+		{
+            CheckValid(texture);
+            
+			var item = _batcher.CreateBatchItem();
+			item.Texture = texture;
+            
+            // set SortKey based on SpriteSortMode.
+            item.SortKey = _sortMode == SpriteSortMode.Texture ? texture.SortingKey : 0;
+            
+            if (sourceRectangle.HasValue)
+            {
+                var srcRect = sourceRectangle.GetValueOrDefault();
+                _texCoordTL.X = srcRect.X * texture.TexelWidth;
+                _texCoordTL.Y = srcRect.Y * texture.TexelHeight;
+                _texCoordBR.X = (srcRect.X + srcRect.Width) * texture.TexelWidth;
+                _texCoordBR.Y = (srcRect.Y + srcRect.Height) * texture.TexelHeight;
+            }
+            else
+            {
+                _texCoordTL = Vector2.Zero;
+                _texCoordBR = Vector2.One;
+            }
+
+            item.Set(destinationRectangle.X,
+                     destinationRectangle.Y,
+                     destinationRectangle.Width,
+                     destinationRectangle.Height,
+                     color,
+                     _texCoordTL,
+                     _texCoordBR,
+                     0);
+            
+            FlushIfNeeded();
+		}
+
+        /// <summary>
+        /// Submit a sprite for drawing in the current batch.
+        /// </summary>
+        /// <param name="texture">A texture.</param>
+        /// <param name="position">The drawing location on screen.</param>
+        /// <param name="color">A color mask.</param>
+		public void Draw (Texture2D texture, Vector2 position, Color color)
+		{
+			CheckValid(texture);
+            
+			var item = _batcher.CreateBatchItem();
+			item.Texture = texture;
+            
+            // set SortKey based on SpriteSortMode.
+            item.SortKey = _sortMode == SpriteSortMode.Texture ? texture.SortingKey : 0;
+            
+            item.Set(position.X,
+                     position.Y,
+                     texture.Width,
+                     texture.Height,
+                     color,
+                     Vector2.Zero,
+                     Vector2.One,
+                     0);
+
+            FlushIfNeeded();
+		}
+
+        /// <summary>
+        /// Submit a sprite for drawing in the current batch.
+        /// </summary>
+        /// <param name="texture">A texture.</param>
+        /// <param name="destinationRectangle">The drawing bounds on screen.</param>
+        /// <param name="color">A color mask.</param>
+        public void Draw(Texture2D texture, Rectangle destinationRectangle, Color color)
+		{
+            CheckValid(texture);
+            
+            var item = _batcher.CreateBatchItem();
+            item.Texture = texture;
+            
+            // set SortKey based on SpriteSortMode.
+            item.SortKey = _sortMode == SpriteSortMode.Texture ? texture.SortingKey : 0;
+            
+            item.Set(destinationRectangle.X,
+                     destinationRectangle.Y,
+                     destinationRectangle.Width,
+                     destinationRectangle.Height,
+                     color,
+                     Vector2.Zero,
+                     Vector2.One,
+                     0);
+            
+            FlushIfNeeded();
+		}
+
+        /// <summary>
+        /// Submit a text string of sprites for drawing in the current batch.
+        /// </summary>
+        /// <param name="spriteFont">A font.</param>
+        /// <param name="text">The text which will be drawn.</param>
+        /// <param name="position">The drawing location on screen.</param>
+        /// <param name="color">A color mask.</param>
+		public unsafe void DrawString (SpriteFont spriteFont, string text, Vector2 position, Color color)
+		{
+            CheckValid(spriteFont, text);
+            
+            float sortKey = (_sortMode == SpriteSortMode.Texture) ? spriteFont.Texture.SortingKey : 0;
+
+            var offset = Vector2.Zero;
+            var firstGlyphOfLine = true;
+
+            fixed (SpriteFont.Glyph* pGlyphs = spriteFont.Glyphs)
+            for (var i = 0; i < text.Length; ++i)
+            {
+                var c = text[i];
+
+                if (c == '\r')
+                    continue;
+
+                if (c == '\n')
+                {
+                    offset.X = 0;
+                    offset.Y += spriteFont.LineSpacing;
+                    firstGlyphOfLine = true;
+                    continue;
+                }
+ 
+                var currentGlyphIndex = spriteFont.GetGlyphIndexOrDefault(c);
+                var pCurrentGlyph = pGlyphs + currentGlyphIndex;
+
+                // The first character on a line might have a negative left side bearing.
+                // In this scenario, SpriteBatch/SpriteFont normally offset the text to the right,
+                //  so that text does not hang off the left side of its rectangle.
+                if (firstGlyphOfLine)
+                {
+                    offset.X = Math.Max(pCurrentGlyph->LeftSideBearing, 0);
+                    firstGlyphOfLine = false;
+                }
+                else
+                {
+                    offset.X += spriteFont.Spacing + pCurrentGlyph->LeftSideBearing;
+                }
+
+                var p = offset;                
+                p.X += pCurrentGlyph->Cropping.X;
+                p.Y += pCurrentGlyph->Cropping.Y;
+                p += position;
+
+                var item = _batcher.CreateBatchItem();
+                item.Texture = spriteFont.Texture;
+                item.SortKey = sortKey;
+            
+                _texCoordTL.X = pCurrentGlyph->BoundsInTexture.X * spriteFont.Texture.TexelWidth;
+                _texCoordTL.Y = pCurrentGlyph->BoundsInTexture.Y * spriteFont.Texture.TexelHeight;
+                _texCoordBR.X = (pCurrentGlyph->BoundsInTexture.X + pCurrentGlyph->BoundsInTexture.Width) * spriteFont.Texture.TexelWidth;
+                _texCoordBR.Y = (pCurrentGlyph->BoundsInTexture.Y + pCurrentGlyph->BoundsInTexture.Height) * spriteFont.Texture.TexelHeight;
+
+                item.Set(p.X,
+                         p.Y,
+                         pCurrentGlyph->BoundsInTexture.Width,
+                         pCurrentGlyph->BoundsInTexture.Height,
+                         color,
+                         _texCoordTL,
+                         _texCoordBR,
+                         0);
+                
+                offset.X += pCurrentGlyph->Width + pCurrentGlyph->RightSideBearing;
+            }
+
+			// We need to flush if we're using Immediate sort mode.
+			FlushIfNeeded();
+		}
+
+        /// <summary>
+        /// Submit a text string of sprites for drawing in the current batch.
+        /// </summary>
+        /// <param name="spriteFont">A font.</param>
+        /// <param name="text">The text which will be drawn.</param>
+        /// <param name="position">The drawing location on screen.</param>
+        /// <param name="color">A color mask.</param>
+        /// <param name="rotation">A rotation of this string.</param>
+        /// <param name="origin">Center of the rotation. 0,0 by default.</param>
+        /// <param name="scale">A scaling of this string.</param>
+        /// <param name="effects">Modificators for drawing. Can be combined.</param>
+        /// <param name="layerDepth">A depth of the layer of this string.</param>
+		public void DrawString (
+			SpriteFont spriteFont, string text, Vector2 position, Color color,
+            float rotation, Vector2 origin, float scale, SpriteEffects effects, float layerDepth)
+		{
+			var scaleVec = new Vector2(scale, scale);
+            DrawString(spriteFont, text, position, color, rotation, origin, scaleVec, effects, layerDepth);
+		}
+
+        /// <summary>
+        /// Submit a text string of sprites for drawing in the current batch.
+        /// </summary>
+        /// <param name="spriteFont">A font.</param>
+        /// <param name="text">The text which will be drawn.</param>
+        /// <param name="position">The drawing location on screen.</param>
+        /// <param name="color">A color mask.</param>
+        /// <param name="rotation">A rotation of this string.</param>
+        /// <param name="origin">Center of the rotation. 0,0 by default.</param>
+        /// <param name="scale">A scaling of this string.</param>
+        /// <param name="effects">Modificators for drawing. Can be combined.</param>
+        /// <param name="layerDepth">A depth of the layer of this string.</param>
+		public unsafe void DrawString (
+			SpriteFont spriteFont, string text, Vector2 position, Color color,
+            float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth)
+		{
+            CheckValid(spriteFont, text);
+            
+            float sortKey = 0;
+            // set SortKey based on SpriteSortMode.
+            switch (_sortMode)
+            {
+                    // Comparison of Texture objects.
+                    case SpriteSortMode.Texture:
+                        sortKey = spriteFont.Texture.SortingKey;
+                        break;
+                    // Comparison of Depth
+                    case SpriteSortMode.FrontToBack:
+                        sortKey = layerDepth;
+                        break;
+                    // Comparison of Depth in reverse
+                    case SpriteSortMode.BackToFront:
+                        sortKey = -layerDepth;
+                        break;
+            }
+
+            var flipAdjustment = Vector2.Zero;
+
+            var flippedVert = (effects & SpriteEffects.FlipVertically) == SpriteEffects.FlipVertically;
+            var flippedHorz = (effects & SpriteEffects.FlipHorizontally) == SpriteEffects.FlipHorizontally;
+
+            if (flippedVert || flippedHorz)
+            {
+                Vector2 size;
+                
+                var source = new SpriteFont.CharacterSource(text);
+                spriteFont.MeasureString(ref source, out size);
+
+                if (flippedHorz)
+                {
+                    origin.X *= -1;
+                    flipAdjustment.X = -size.X;
+                }
+
+                if (flippedVert)
+                {
+                    origin.Y *= -1;
+                    flipAdjustment.Y = spriteFont.LineSpacing - size.Y;
+                }
+            }
+            
+            Matrix transformation = Matrix.Identity;
+            float cos = 0, sin = 0;
+            if (rotation == 0)
+            {
+                transformation.M11 = (flippedHorz ? -scale.X : scale.X);
+                transformation.M22 = (flippedVert ? -scale.Y : scale.Y);
+                transformation.M41 = ((flipAdjustment.X - origin.X) * transformation.M11) + position.X;
+                transformation.M42 = ((flipAdjustment.Y - origin.Y) * transformation.M22) + position.Y;
+            }
+            else
+            {
+                cos = (float)Math.Cos(rotation);
+                sin = (float)Math.Sin(rotation);
+                transformation.M11 = (flippedHorz ? -scale.X : scale.X) * cos;
+                transformation.M12 = (flippedHorz ? -scale.X : scale.X) * sin;
+                transformation.M21 = (flippedVert ? -scale.Y : scale.Y) * (-sin);
+                transformation.M22 = (flippedVert ? -scale.Y : scale.Y) * cos;
+                transformation.M41 = (((flipAdjustment.X - origin.X) * transformation.M11) + (flipAdjustment.Y - origin.Y) * transformation.M21) + position.X;
+                transformation.M42 = (((flipAdjustment.X - origin.X) * transformation.M12) + (flipAdjustment.Y - origin.Y) * transformation.M22) + position.Y; 
+            }
+
+            var offset = Vector2.Zero;
+            var firstGlyphOfLine = true;
+
+            fixed (SpriteFont.Glyph* pGlyphs = spriteFont.Glyphs)
+            for (var i = 0; i < text.Length; ++i)
+            {
+                var c = text[i];
+
+                if (c == '\r')
+                    continue;
+
+                if (c == '\n')
+                {
+                    offset.X = 0;
+                    offset.Y += spriteFont.LineSpacing;
+                    firstGlyphOfLine = true;
+                    continue;
+                }
+
+                var currentGlyphIndex = spriteFont.GetGlyphIndexOrDefault(c);
+                var pCurrentGlyph = pGlyphs + currentGlyphIndex;
+
+                // The first character on a line might have a negative left side bearing.
+                // In this scenario, SpriteBatch/SpriteFont normally offset the text to the right,
+                //  so that text does not hang off the left side of its rectangle.
+                if (firstGlyphOfLine)
+                {
+                    offset.X = Math.Max(pCurrentGlyph->LeftSideBearing, 0);
+                    firstGlyphOfLine = false;
+                }
+                else
+                {
+                    offset.X += spriteFont.Spacing + pCurrentGlyph->LeftSideBearing;
+                }
+
+                var p = offset;
+
+                if (flippedHorz)
+                    p.X += pCurrentGlyph->BoundsInTexture.Width;
+                p.X += pCurrentGlyph->Cropping.X;
+
+                if (flippedVert)
+                    p.Y += pCurrentGlyph->BoundsInTexture.Height - spriteFont.LineSpacing;
+                p.Y += pCurrentGlyph->Cropping.Y;
+
+                Vector2.Transform(ref p, ref transformation, out p);
+
+                var item = _batcher.CreateBatchItem();               
+                item.Texture = spriteFont.Texture;
+                item.SortKey = sortKey;
+                
+                _texCoordTL.X = pCurrentGlyph->BoundsInTexture.X * spriteFont.Texture.TexelWidth;
+                _texCoordTL.Y = pCurrentGlyph->BoundsInTexture.Y * spriteFont.Texture.TexelHeight;
+                _texCoordBR.X = (pCurrentGlyph->BoundsInTexture.X + pCurrentGlyph->BoundsInTexture.Width) * spriteFont.Texture.TexelWidth;
+                _texCoordBR.Y = (pCurrentGlyph->BoundsInTexture.Y + pCurrentGlyph->BoundsInTexture.Height) * spriteFont.Texture.TexelHeight;
+                            
+                if ((effects & SpriteEffects.FlipVertically) != 0)
+                {
+                    var temp = _texCoordBR.Y;
+				    _texCoordBR.Y = _texCoordTL.Y;
+				    _texCoordTL.Y = temp;
+			    }
+                if ((effects & SpriteEffects.FlipHorizontally) != 0)
+                {
+                    var temp = _texCoordBR.X;
+				    _texCoordBR.X = _texCoordTL.X;
+				    _texCoordTL.X = temp;
+			    }
+
+                if (rotation == 0f)
+                {
+                    item.Set(p.X,
+                            p.Y,
+                            pCurrentGlyph->BoundsInTexture.Width * scale.X,
+                            pCurrentGlyph->BoundsInTexture.Height * scale.Y,
+                            color,
+                            _texCoordTL,
+                            _texCoordBR,
+                            layerDepth);
+                }
+                else
+                {
+                    item.Set(p.X,
+                            p.Y,
+                            0,
+                            0,
+                            pCurrentGlyph->BoundsInTexture.Width * scale.X,
+                            pCurrentGlyph->BoundsInTexture.Height * scale.Y,
+                            sin,
+                            cos,
+                            color,
+                            _texCoordTL,
+                            _texCoordBR,
+                            layerDepth);
+                }
+                
+                offset.X += pCurrentGlyph->Width + pCurrentGlyph->RightSideBearing;
+            }
+
+			// We need to flush if we're using Immediate sort mode.
+			FlushIfNeeded();
+		}
+
+        /// <summary>
+        /// Submit a text string of sprites for drawing in the current batch.
+        /// </summary>
+        /// <param name="spriteFont">A font.</param>
+        /// <param name="text">The text which will be drawn.</param>
+        /// <param name="position">The drawing location on screen.</param>
+        /// <param name="color">A color mask.</param>
+		public unsafe void DrawString (SpriteFont spriteFont, StringBuilder text, Vector2 position, Color color)
+		{
+            CheckValid(spriteFont, text);
+            
+            float sortKey =  (_sortMode == SpriteSortMode.Texture) ? spriteFont.Texture.SortingKey : 0;
+
+            var offset = Vector2.Zero;
+            var firstGlyphOfLine = true;
+
+            fixed (SpriteFont.Glyph* pGlyphs = spriteFont.Glyphs)
+            for (var i = 0; i < text.Length; ++i)
+            {
+                var c = text[i];
+
+                if (c == '\r')
+                    continue;
+
+                if (c == '\n')
+                {
+                    offset.X = 0;
+                    offset.Y += spriteFont.LineSpacing;
+                    firstGlyphOfLine = true;
+                    continue;
+                }
+
+                var currentGlyphIndex = spriteFont.GetGlyphIndexOrDefault(c);
+                var pCurrentGlyph = pGlyphs + currentGlyphIndex;
+
+                // The first character on a line might have a negative left side bearing.
+                // In this scenario, SpriteBatch/SpriteFont normally offset the text to the right,
+                //  so that text does not hang off the left side of its rectangle.
+                if (firstGlyphOfLine)
+                {
+                    offset.X = Math.Max(pCurrentGlyph->LeftSideBearing, 0);
+                    firstGlyphOfLine = false;
+                }
+                else
+                {
+                    offset.X += spriteFont.Spacing + pCurrentGlyph->LeftSideBearing;
+                }
+
+                var p = offset;                
+                p.X += pCurrentGlyph->Cropping.X;
+                p.Y += pCurrentGlyph->Cropping.Y;
+                p += position;
+                
+                var item = _batcher.CreateBatchItem();
+                item.Texture = spriteFont.Texture;
+                item.SortKey = sortKey;
+            
+                _texCoordTL.X = pCurrentGlyph->BoundsInTexture.X * spriteFont.Texture.TexelWidth;
+                _texCoordTL.Y = pCurrentGlyph->BoundsInTexture.Y * spriteFont.Texture.TexelHeight;
+                _texCoordBR.X = (pCurrentGlyph->BoundsInTexture.X + pCurrentGlyph->BoundsInTexture.Width) * spriteFont.Texture.TexelWidth;
+                _texCoordBR.Y = (pCurrentGlyph->BoundsInTexture.Y + pCurrentGlyph->BoundsInTexture.Height) * spriteFont.Texture.TexelHeight;
+
+                item.Set(p.X,
+                         p.Y,
+                         pCurrentGlyph->BoundsInTexture.Width,
+                         pCurrentGlyph->BoundsInTexture.Height,
+                         color,
+                         _texCoordTL,
+                         _texCoordBR,
+                         0);
+
+                offset.X += pCurrentGlyph->Width + pCurrentGlyph->RightSideBearing;
+            }
+
+			// We need to flush if we're using Immediate sort mode.
+			FlushIfNeeded();
+		}
+
+        /// <summary>
+        /// Submit a text string of sprites for drawing in the current batch.
+        /// </summary>
+        /// <param name="spriteFont">A font.</param>
+        /// <param name="text">The text which will be drawn.</param>
+        /// <param name="position">The drawing location on screen.</param>
+        /// <param name="color">A color mask.</param>
+        /// <param name="rotation">A rotation of this string.</param>
+        /// <param name="origin">Center of the rotation. 0,0 by default.</param>
+        /// <param name="scale">A scaling of this string.</param>
+        /// <param name="effects">Modificators for drawing. Can be combined.</param>
+        /// <param name="layerDepth">A depth of the layer of this string.</param>
+		public void DrawString (
+			SpriteFont spriteFont, StringBuilder text, Vector2 position, Color color,
+            float rotation, Vector2 origin, float scale, SpriteEffects effects, float layerDepth)
+		{
+			var scaleVec = new Vector2 (scale, scale);
+            DrawString(spriteFont, text, position, color, rotation, origin, scaleVec, effects, layerDepth);
+		}
+
+        /// <summary>
+        /// Submit a text string of sprites for drawing in the current batch.
+        /// </summary>
+        /// <param name="spriteFont">A font.</param>
+        /// <param name="text">The text which will be drawn.</param>
+        /// <param name="position">The drawing location on screen.</param>
+        /// <param name="color">A color mask.</param>
+        /// <param name="rotation">A rotation of this string.</param>
+        /// <param name="origin">Center of the rotation. 0,0 by default.</param>
+        /// <param name="scale">A scaling of this string.</param>
+        /// <param name="effects">Modificators for drawing. Can be combined.</param>
+        /// <param name="layerDepth">A depth of the layer of this string.</param>
+		public unsafe void DrawString (
+			SpriteFont spriteFont, StringBuilder text, Vector2 position, Color color,
+            float rotation, Vector2 origin, Vector2 scale, SpriteEffects effects, float layerDepth)
+		{
+            CheckValid(spriteFont, text);
+            
+            float sortKey = 0;
+            // set SortKey based on SpriteSortMode.
+            switch (_sortMode)
+            {
+                    // Comparison of Texture objects.
+                    case SpriteSortMode.Texture:
+                        sortKey = spriteFont.Texture.SortingKey;
+                        break;
+                    // Comparison of Depth
+                    case SpriteSortMode.FrontToBack:
+                        sortKey = layerDepth;
+                        break;
+                    // Comparison of Depth in reverse
+                    case SpriteSortMode.BackToFront:
+                        sortKey = -layerDepth;
+                        break;
+            }
+
+            var flipAdjustment = Vector2.Zero;
+
+            var flippedVert = (effects & SpriteEffects.FlipVertically) == SpriteEffects.FlipVertically;
+            var flippedHorz = (effects & SpriteEffects.FlipHorizontally) == SpriteEffects.FlipHorizontally;
+
+            if (flippedVert || flippedHorz)
+            {
+                var source = new SpriteFont.CharacterSource(text);
+                Vector2 size;
+                spriteFont.MeasureString(ref source, out size);
+
+                if (flippedHorz)
+                {
+                    origin.X *= -1;
+                    flipAdjustment.X = -size.X;
+                }
+
+                if (flippedVert)
+                {
+                    origin.Y *= -1;
+                    flipAdjustment.Y = spriteFont.LineSpacing - size.Y;
+                }
+            }
+            
+            Matrix transformation = Matrix.Identity;
+            float cos = 0, sin = 0;
+            if (rotation == 0)
+            {
+                transformation.M11 = (flippedHorz ? -scale.X : scale.X);
+                transformation.M22 = (flippedVert ? -scale.Y : scale.Y);
+                transformation.M41 = ((flipAdjustment.X - origin.X) * transformation.M11) + position.X;
+                transformation.M42 = ((flipAdjustment.Y - origin.Y) * transformation.M22) + position.Y;
+            }
+            else
+            {
+                cos = (float)Math.Cos(rotation);
+                sin = (float)Math.Sin(rotation);
+                transformation.M11 = (flippedHorz ? -scale.X : scale.X) * cos;
+                transformation.M12 = (flippedHorz ? -scale.X : scale.X) * sin;
+                transformation.M21 = (flippedVert ? -scale.Y : scale.Y) * (-sin);
+                transformation.M22 = (flippedVert ? -scale.Y : scale.Y) * cos;
+                transformation.M41 = (((flipAdjustment.X - origin.X) * transformation.M11) + (flipAdjustment.Y - origin.Y) * transformation.M21) + position.X;
+                transformation.M42 = (((flipAdjustment.X - origin.X) * transformation.M12) + (flipAdjustment.Y - origin.Y) * transformation.M22) + position.Y; 
+            }
+
+            var offset = Vector2.Zero;
+            var firstGlyphOfLine = true;
+
+            fixed (SpriteFont.Glyph* pGlyphs = spriteFont.Glyphs)
+            for (var i = 0; i < text.Length; ++i)
+            {
+                var c = text[i];
+
+                if (c == '\r')
+                    continue;
+
+                if (c == '\n')
+                {
+                    offset.X = 0;
+                    offset.Y += spriteFont.LineSpacing;
+                    firstGlyphOfLine = true;
+                    continue;
+                }
+
+                var currentGlyphIndex = spriteFont.GetGlyphIndexOrDefault(c);
+                var pCurrentGlyph = pGlyphs + currentGlyphIndex;
+
+                // The first character on a line might have a negative left side bearing.
+                // In this scenario, SpriteBatch/SpriteFont normally offset the text to the right,
+                //  so that text does not hang off the left side of its rectangle.
+                if (firstGlyphOfLine)
+                {
+                    offset.X = Math.Max(pCurrentGlyph->LeftSideBearing, 0);
+                    firstGlyphOfLine = false;
+                }
+                else
+                {
+                    offset.X += spriteFont.Spacing + pCurrentGlyph->LeftSideBearing;
+                }
+
+                var p = offset;
+
+                if (flippedHorz)
+                    p.X += pCurrentGlyph->BoundsInTexture.Width;
+                p.X += pCurrentGlyph->Cropping.X;
+
+                if (flippedVert)
+                    p.Y += pCurrentGlyph->BoundsInTexture.Height - spriteFont.LineSpacing;
+                p.Y += pCurrentGlyph->Cropping.Y;
+
+                Vector2.Transform(ref p, ref transformation, out p);
+                
+                var item = _batcher.CreateBatchItem();               
+                item.Texture = spriteFont.Texture;
+                item.SortKey = sortKey;
+                
+                _texCoordTL.X = pCurrentGlyph->BoundsInTexture.X * (float)spriteFont.Texture.TexelWidth;
+                _texCoordTL.Y = pCurrentGlyph->BoundsInTexture.Y * (float)spriteFont.Texture.TexelHeight;
+                _texCoordBR.X = (pCurrentGlyph->BoundsInTexture.X + pCurrentGlyph->BoundsInTexture.Width) * (float)spriteFont.Texture.TexelWidth;
+                _texCoordBR.Y = (pCurrentGlyph->BoundsInTexture.Y + pCurrentGlyph->BoundsInTexture.Height) * (float)spriteFont.Texture.TexelHeight;
+                            
+                if ((effects & SpriteEffects.FlipVertically) != 0)
+                {
+                    var temp = _texCoordBR.Y;
+				    _texCoordBR.Y = _texCoordTL.Y;
+				    _texCoordTL.Y = temp;
+			    }
+                if ((effects & SpriteEffects.FlipHorizontally) != 0)
+                {
+                    var temp = _texCoordBR.X;
+				    _texCoordBR.X = _texCoordTL.X;
+				    _texCoordTL.X = temp;
+			    }
+
+                if (rotation == 0f)
+                {
+                    item.Set(p.X,
+                            p.Y,
+                            pCurrentGlyph->BoundsInTexture.Width * scale.X,
+                            pCurrentGlyph->BoundsInTexture.Height * scale.Y,
+                            color,
+                            _texCoordTL,
+                            _texCoordBR,
+                            layerDepth);
+                }
+                else
+                {
+                    item.Set(p.X,
+                            p.Y,
+                            0,
+                            0,
+                            pCurrentGlyph->BoundsInTexture.Width * scale.X,
+                            pCurrentGlyph->BoundsInTexture.Height * scale.Y,
+                            sin,
+                            cos,
+                            color,
+                            _texCoordTL,
+                            _texCoordBR,
+                            layerDepth);
+                }
+
+                offset.X += pCurrentGlyph->Width + pCurrentGlyph->RightSideBearing;
+			}
+
+			// We need to flush if we're using Immediate sort mode.
+			FlushIfNeeded();
+		}
+
+        /// <summary>
+        /// Immediately releases the unmanaged resources used by this object.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                if (disposing)
+                {
+                    if (_spriteEffect != null)
+                    {
+                        _spriteEffect.Dispose();
+                        _spriteEffect = null;
+                    }
+                }
+            }
+            base.Dispose(disposing);
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/SpriteBatchItem.cs b/MonoGame.Framework/Graphics/SpriteBatchItem.cs
new file mode 100644
index 00000000000..68e23646c20
--- /dev/null
+++ b/MonoGame.Framework/Graphics/SpriteBatchItem.cs
@@ -0,0 +1,99 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    internal class SpriteBatchItem : IComparable<SpriteBatchItem>
+	{
+		public Texture2D Texture;
+        public float SortKey;
+
+        public VertexPositionColorTexture vertexTL;
+		public VertexPositionColorTexture vertexTR;
+		public VertexPositionColorTexture vertexBL;
+		public VertexPositionColorTexture vertexBR;
+		public SpriteBatchItem ()
+		{
+			vertexTL = new VertexPositionColorTexture();
+            vertexTR = new VertexPositionColorTexture();
+            vertexBL = new VertexPositionColorTexture();
+            vertexBR = new VertexPositionColorTexture();            
+		}
+		
+		public void Set ( float x, float y, float dx, float dy, float w, float h, float sin, float cos, Color color, Vector2 texCoordTL, Vector2 texCoordBR, float depth )
+		{
+            // TODO, Should we be just assigning the Depth Value to Z?
+            // According to http://blogs.msdn.com/b/shawnhar/archive/2011/01/12/spritebatch-billboards-in-a-3d-world.aspx
+            // We do.
+			vertexTL.Position.X = x+dx*cos-dy*sin;
+            vertexTL.Position.Y = y+dx*sin+dy*cos;
+            vertexTL.Position.Z = depth;
+            vertexTL.Color = color;
+            vertexTL.TextureCoordinate.X = texCoordTL.X;
+            vertexTL.TextureCoordinate.Y = texCoordTL.Y;
+
+			vertexTR.Position.X = x+(dx+w)*cos-dy*sin;
+            vertexTR.Position.Y = y+(dx+w)*sin+dy*cos;
+            vertexTR.Position.Z = depth;
+            vertexTR.Color = color;
+            vertexTR.TextureCoordinate.X = texCoordBR.X;
+            vertexTR.TextureCoordinate.Y = texCoordTL.Y;
+
+			vertexBL.Position.X = x+dx*cos-(dy+h)*sin;
+            vertexBL.Position.Y = y+dx*sin+(dy+h)*cos;
+            vertexBL.Position.Z = depth;
+            vertexBL.Color = color;
+            vertexBL.TextureCoordinate.X = texCoordTL.X;
+            vertexBL.TextureCoordinate.Y = texCoordBR.Y;
+
+			vertexBR.Position.X = x+(dx+w)*cos-(dy+h)*sin;
+            vertexBR.Position.Y = y+(dx+w)*sin+(dy+h)*cos;
+            vertexBR.Position.Z = depth;
+            vertexBR.Color = color;
+            vertexBR.TextureCoordinate.X = texCoordBR.X;
+            vertexBR.TextureCoordinate.Y = texCoordBR.Y;
+		}
+
+        public void Set(float x, float y, float w, float h, Color color, Vector2 texCoordTL, Vector2 texCoordBR, float depth)
+        {
+            vertexTL.Position.X = x;
+            vertexTL.Position.Y = y;
+            vertexTL.Position.Z = depth;
+            vertexTL.Color = color;
+            vertexTL.TextureCoordinate.X = texCoordTL.X;
+            vertexTL.TextureCoordinate.Y = texCoordTL.Y;
+
+            vertexTR.Position.X = x + w;
+            vertexTR.Position.Y = y;
+            vertexTR.Position.Z = depth;
+            vertexTR.Color = color;
+            vertexTR.TextureCoordinate.X = texCoordBR.X;
+            vertexTR.TextureCoordinate.Y = texCoordTL.Y;
+
+            vertexBL.Position.X = x;
+            vertexBL.Position.Y = y + h;
+            vertexBL.Position.Z = depth;
+            vertexBL.Color = color;
+            vertexBL.TextureCoordinate.X = texCoordTL.X;
+            vertexBL.TextureCoordinate.Y = texCoordBR.Y;
+
+            vertexBR.Position.X = x + w;
+            vertexBR.Position.Y = y + h;
+            vertexBR.Position.Z = depth;
+            vertexBR.Color = color;
+            vertexBR.TextureCoordinate.X = texCoordBR.X;
+            vertexBR.TextureCoordinate.Y = texCoordBR.Y;
+        }
+
+        #region Implement IComparable
+        public int CompareTo(SpriteBatchItem other)
+        {
+            return SortKey.CompareTo(other.SortKey);
+        }
+        #endregion
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/SpriteBatcher.cs b/MonoGame.Framework/Graphics/SpriteBatcher.cs
new file mode 100644
index 00000000000..0ad0333ec77
--- /dev/null
+++ b/MonoGame.Framework/Graphics/SpriteBatcher.cs
@@ -0,0 +1,283 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// This class handles the queueing of batch items into the GPU by creating the triangle tesselations
+    /// that are used to draw the sprite textures. This class supports int.MaxValue number of sprites to be
+    /// batched and will process them into short.MaxValue groups (strided by 6 for the number of vertices
+    /// sent to the GPU). 
+    /// </summary>
+	internal class SpriteBatcher
+	{
+        /*
+         * Note that this class is fundamental to high performance for SpriteBatch games. Please exercise
+         * caution when making changes to this class.
+         */
+
+        /// <summary>
+        /// Initialization size for the batch item list and queue.
+        /// </summary>
+        private const int InitialBatchSize = 256;
+        /// <summary>
+        /// The maximum number of batch items that can be processed per iteration
+        /// </summary>
+        private const int MaxBatchSize = short.MaxValue / 6; // 6 = 4 vertices unique and 2 shared, per quad
+        /// <summary>
+        /// Initialization size for the vertex array, in batch units.
+        /// </summary>
+		private const int InitialVertexArraySize = 256;
+
+        /// <summary>
+        /// The list of batch items to process.
+        /// </summary>
+	    private SpriteBatchItem[] _batchItemList;
+        /// <summary>
+        /// Index pointer to the next available SpriteBatchItem in _batchItemList.
+        /// </summary>
+        private int _batchItemCount;
+        
+        /// <summary>
+        /// The target graphics device.
+        /// </summary>
+        private readonly GraphicsDevice _device;
+
+        /// <summary>
+        /// Vertex index array. The values in this array never change.
+        /// </summary>
+        private short[] _index;
+
+        private VertexPositionColorTexture[] _vertexArray;
+
+		public SpriteBatcher (GraphicsDevice device)
+		{
+            _device = device;
+
+			_batchItemList = new SpriteBatchItem[InitialBatchSize];
+            _batchItemCount = 0;
+
+            for (int i = 0; i < InitialBatchSize; i++)
+                _batchItemList[i] = new SpriteBatchItem();
+
+            EnsureArrayCapacity(InitialBatchSize);
+		}
+
+        /// <summary>
+        /// Reuse a previously allocated SpriteBatchItem from the item pool. 
+        /// if there is none available grow the pool and initialize new items.
+        /// </summary>
+        /// <returns></returns>
+        public SpriteBatchItem CreateBatchItem()
+        {
+            if (_batchItemCount >= _batchItemList.Length)
+            {
+                var oldSize = _batchItemList.Length;
+                var newSize = oldSize + oldSize/2; // grow by x1.5
+                newSize = (newSize + 63) & (~63); // grow in chunks of 64.
+                Array.Resize(ref _batchItemList, newSize);
+                for(int i=oldSize; i<newSize; i++)
+                    _batchItemList[i]=new SpriteBatchItem();
+
+                EnsureArrayCapacity(Math.Min(newSize, MaxBatchSize));
+            }
+            var item = _batchItemList[_batchItemCount++];
+            return item;
+        }
+
+        /// <summary>
+        /// Resize and recreate the missing indices for the index and vertex position color buffers.
+        /// </summary>
+        /// <param name="numBatchItems"></param>
+        private unsafe void EnsureArrayCapacity(int numBatchItems)
+        {
+            int neededCapacity = 6 * numBatchItems;
+            if (_index != null && neededCapacity <= _index.Length)
+            {
+                // Short circuit out of here because we have enough capacity.
+                return;
+            }
+            short[] newIndex = new short[6 * numBatchItems];
+            int start = 0;
+            if (_index != null)
+            {
+                _index.CopyTo(newIndex, 0);
+                start = _index.Length / 6;
+            }
+            fixed (short* indexFixedPtr = newIndex)
+            {
+                var indexPtr = indexFixedPtr + (start * 6);
+                for (var i = start; i < numBatchItems; i++, indexPtr += 6)
+                {
+                    /*
+                     *  TL    TR
+                     *   0----1 0,1,2,3 = index offsets for vertex indices
+                     *   |   /| TL,TR,BL,BR are vertex references in SpriteBatchItem.
+                     *   |  / |
+                     *   | /  |
+                     *   |/   |
+                     *   2----3
+                     *  BL    BR
+                     */
+                    // Triangle 1
+                    *(indexPtr + 0) = (short)(i * 4);
+                    *(indexPtr + 1) = (short)(i * 4 + 1);
+                    *(indexPtr + 2) = (short)(i * 4 + 2);
+                    // Triangle 2
+                    *(indexPtr + 3) = (short)(i * 4 + 1);
+                    *(indexPtr + 4) = (short)(i * 4 + 3);
+                    *(indexPtr + 5) = (short)(i * 4 + 2);
+                }
+            }
+            _index = newIndex;
+
+            _vertexArray = new VertexPositionColorTexture[4 * numBatchItems];
+        }
+                
+        /// <summary>
+        /// Sorts the batch items and then groups batch drawing into maximal allowed batch sets that do not
+        /// overflow the 16 bit array indices for vertices.
+        /// </summary>
+        /// <param name="sortMode">The type of depth sorting desired for the rendering.</param>
+        /// <param name="effect">The custom effect to apply to the drawn geometry</param>
+        public unsafe void DrawBatch(SpriteSortMode sortMode, Effect effect)
+		{
+            if (effect != null && effect.IsDisposed)
+                throw new ObjectDisposedException("effect");
+
+			// nothing to do
+            if (_batchItemCount == 0)
+				return;
+			
+			// sort the batch items
+			switch ( sortMode )
+			{
+			case SpriteSortMode.Texture :                
+			case SpriteSortMode.FrontToBack :
+			case SpriteSortMode.BackToFront :
+                Array.Sort(_batchItemList, 0, _batchItemCount);
+				break;
+			}
+
+            // Determine how many iterations through the drawing code we need to make
+            int batchIndex = 0;
+            int batchCount = _batchItemCount;
+
+            
+            unchecked
+            {
+                _device._graphicsMetrics._spriteCount += batchCount;
+            }
+
+            // Iterate through the batches, doing short.MaxValue sets of vertices only.
+            while(batchCount > 0)
+            {
+                // setup the vertexArray array
+                var startIndex = 0;
+                var index = 0;
+                Texture2D tex = null;
+
+                int numBatchesToProcess = batchCount;
+                if (numBatchesToProcess > MaxBatchSize)
+                {
+                    numBatchesToProcess = MaxBatchSize;
+                }
+                // Avoid the array checking overhead by using pointer indexing!
+                fixed (VertexPositionColorTexture* vertexArrayFixedPtr = _vertexArray)
+                {
+                    var vertexArrayPtr = vertexArrayFixedPtr;
+
+                    // Draw the batches
+                    for (int i = 0; i < numBatchesToProcess; i++, batchIndex++, index += 4, vertexArrayPtr += 4)
+                    {
+                        SpriteBatchItem item = _batchItemList[batchIndex];
+                        // if the texture changed, we need to flush and bind the new texture
+                        var shouldFlush = !ReferenceEquals(item.Texture, tex);
+                        if (shouldFlush)
+                        {
+                            FlushVertexArray(startIndex, index, effect, tex);
+
+                            tex = item.Texture;
+                            startIndex = index = 0;
+                            vertexArrayPtr = vertexArrayFixedPtr;
+                            _device.Textures[0] = tex;
+                        }
+
+                        // store the SpriteBatchItem data in our vertexArray
+                        *(vertexArrayPtr+0) = item.vertexTL;
+                        *(vertexArrayPtr+1) = item.vertexTR;
+                        *(vertexArrayPtr+2) = item.vertexBL;
+                        *(vertexArrayPtr+3) = item.vertexBR;
+
+                        // Release the texture.
+                        item.Texture = null;
+                    }
+                }
+                // flush the remaining vertexArray data
+                FlushVertexArray(startIndex, index, effect, tex);
+                // Update our batch count to continue the process of culling down
+                // large batches
+                batchCount -= numBatchesToProcess;
+            }
+            // return items to the pool.  
+            _batchItemCount = 0;
+		}
+
+        /// <summary>
+        /// Sends the triangle list to the graphics device. Here is where the actual drawing starts.
+        /// </summary>
+        /// <param name="start">Start index of vertices to draw. Not used except to compute the count of vertices to draw.</param>
+        /// <param name="end">End index of vertices to draw. Not used except to compute the count of vertices to draw.</param>
+        /// <param name="effect">The custom effect to apply to the geometry</param>
+        /// <param name="texture">The texture to draw.</param>
+        private void FlushVertexArray(int start, int end, Effect effect, Texture texture)
+        {
+            if (start == end)
+                return;
+
+            var vertexCount = end - start;
+
+            // If the effect is not null, then apply each pass and render the geometry
+            if (effect != null)
+            {
+                var passes = effect.CurrentTechnique.Passes;
+                foreach (var pass in passes)
+                {
+                    pass.Apply();
+
+                    // Whatever happens in pass.Apply, make sure the texture being drawn
+                    // ends up in Textures[0].
+                    _device.Textures[0] = texture;
+
+                    _device.DrawUserIndexedPrimitives(
+                        PrimitiveType.TriangleList,
+                        _vertexArray,
+                        0,
+                        vertexCount,
+                        _index,
+                        0,
+                        (vertexCount / 4) * 2,
+                        VertexPositionColorTexture.VertexDeclaration);
+                }
+            }
+            else
+            {
+                // If no custom effect is defined, then simply render.
+                _device.DrawUserIndexedPrimitives(
+                    PrimitiveType.TriangleList,
+                    _vertexArray,
+                    0,
+                    vertexCount,
+                    _index,
+                    0,
+                    (vertexCount / 4) * 2,
+                    VertexPositionColorTexture.VertexDeclaration);
+            }
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/SpriteEffects.cs b/MonoGame.Framework/Graphics/SpriteEffects.cs
new file mode 100644
index 00000000000..3b833b56c26
--- /dev/null
+++ b/MonoGame.Framework/Graphics/SpriteEffects.cs
@@ -0,0 +1,28 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines sprite visual options for mirroring.
+    /// </summary>
+    [Flags]
+    public enum SpriteEffects
+    {
+        /// <summary>
+        /// No options specified.
+        /// </summary>
+		None = 0,
+        /// <summary>
+        /// Render the sprite reversed along the X axis.
+        /// </summary>
+        FlipHorizontally = 1,
+        /// <summary>
+        /// Render the sprite reversed along the Y axis.
+        /// </summary>
+        FlipVertically = 2
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/SpriteFont.cs b/MonoGame.Framework/Graphics/SpriteFont.cs
new file mode 100644
index 00000000000..3872f7cfcac
--- /dev/null
+++ b/MonoGame.Framework/Graphics/SpriteFont.cs
@@ -0,0 +1,404 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+// Original code from SilverSprite Project
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Text;
+
+namespace Microsoft.Xna.Framework.Graphics 
+{
+
+	public sealed class SpriteFont 
+    {
+		internal static class Errors 
+        {
+			public const string TextContainsUnresolvableCharacters =
+				"Text contains characters that cannot be resolved by this SpriteFont.";
+			public const string UnresolvableCharacter =
+				"Character cannot be resolved by this SpriteFont.";
+		}
+
+        private readonly Glyph[] _glyphs;
+        private readonly CharacterRegion[] _regions;
+        private char? _defaultCharacter;
+        private int _defaultGlyphIndex = -1;
+		
+		private readonly Texture2D _texture;
+
+		/// <summary>
+		/// All the glyphs in this SpriteFont.
+		/// </summary>
+		public Glyph[] Glyphs { get { return _glyphs; } }
+
+		class CharComparer: IEqualityComparer<char>
+		{
+			public bool Equals(char x, char y)
+			{
+				return x == y;
+			}
+
+			public int GetHashCode(char b)
+			{
+				return (b);
+			}
+
+			static public readonly CharComparer Default = new CharComparer();
+		}
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="SpriteFont" /> class.
+		/// </summary>
+		/// <param name="texture">The font texture.</param>
+		/// <param name="glyphBounds">The rectangles in the font texture containing letters.</param>
+		/// <param name="cropping">The cropping rectangles, which are applied to the corresponding glyphBounds to calculate the bounds of the actual character.</param>
+		/// <param name="characters">The characters.</param>
+		/// <param name="lineSpacing">The line spacing (the distance from baseline to baseline) of the font.</param>
+		/// <param name="spacing">The spacing (tracking) between characters in the font.</param>
+		/// <param name="kerning">The letters kernings(X - left side bearing, Y - width and Z - right side bearing).</param>
+		/// <param name="defaultCharacter">The character that will be substituted when a given character is not included in the font.</param>
+		public SpriteFont (
+			Texture2D texture, List<Rectangle> glyphBounds, List<Rectangle> cropping, List<char> characters,
+			int lineSpacing, float spacing, List<Vector3> kerning, char? defaultCharacter)
+		{
+			Characters = new ReadOnlyCollection<char>(characters.ToArray());
+			_texture = texture;
+			LineSpacing = lineSpacing;
+			Spacing = spacing;
+
+            _glyphs = new Glyph[characters.Count];
+            var regions = new Stack<CharacterRegion>();
+
+			for (var i = 0; i < characters.Count; i++) 
+            {
+				_glyphs[i] = new Glyph 
+                {
+					BoundsInTexture = glyphBounds[i],
+					Cropping = cropping[i],
+                    Character = characters[i],
+
+                    LeftSideBearing = kerning[i].X,
+                    Width = kerning[i].Y,
+                    RightSideBearing = kerning[i].Z,
+
+                    WidthIncludingBearings = kerning[i].X + kerning[i].Y + kerning[i].Z
+				};
+                
+                if(regions.Count == 0 || characters[i] > (regions.Peek().End+1))
+                {
+                    // Start a new region
+                    regions.Push(new CharacterRegion(characters[i], i));
+                } 
+                else if(characters[i] == (regions.Peek().End+1))
+                {
+                    var currentRegion = regions.Pop();
+                    // include character in currentRegion
+                    currentRegion.End++;
+                    regions.Push(currentRegion);
+                }
+                else // characters[i] < (regions.Peek().End+1)
+                {
+                    throw new InvalidOperationException("Invalid SpriteFont. Character map must be in ascending order.");
+                }
+			}
+
+            _regions = regions.ToArray();
+            Array.Reverse(_regions);
+
+			DefaultCharacter = defaultCharacter;
+		}
+
+        /// <summary>
+        /// Gets the texture that this SpriteFont draws from.
+        /// </summary>
+        /// <remarks>Can be used to implement custom rendering of a SpriteFont</remarks>
+        public Texture2D Texture { get { return _texture; } }
+
+        /// <summary>
+        /// Returns a copy of the dictionary containing the glyphs in this SpriteFont.
+        /// </summary>
+        /// <returns>A new Dictionary containing all of the glyphs inthis SpriteFont</returns>
+        /// <remarks>Can be used to calculate character bounds when implementing custom SpriteFont rendering.</remarks>
+        public Dictionary<char, Glyph> GetGlyphs()
+        {
+            var glyphsDictionary = new Dictionary<char, Glyph>(_glyphs.Length, CharComparer.Default);
+            foreach(var glyph in _glyphs)
+                glyphsDictionary.Add(glyph.Character, glyph);
+            return glyphsDictionary;
+        }
+
+		/// <summary>
+		/// Gets a collection of the characters in the font.
+		/// </summary>
+		public ReadOnlyCollection<char> Characters { get; private set; }
+
+		/// <summary>
+		/// Gets or sets the character that will be substituted when a
+		/// given character is not included in the font.
+		/// </summary>
+		public char? DefaultCharacter
+        {
+            get { return _defaultCharacter; }
+            set
+            {   
+                // Get the default glyph index here once.
+                if (value.HasValue)
+                {
+                    if(!TryGetGlyphIndex(value.Value, out _defaultGlyphIndex))
+                        throw new ArgumentException(Errors.UnresolvableCharacter);
+                }
+                else
+                    _defaultGlyphIndex = -1;
+
+                _defaultCharacter = value;
+            }
+        }
+
+		/// <summary>
+		/// Gets or sets the line spacing (the distance from baseline
+		/// to baseline) of the font.
+		/// </summary>
+		public int LineSpacing { get; set; }
+
+		/// <summary>
+		/// Gets or sets the spacing (tracking) between characters in
+		/// the font.
+		/// </summary>
+		public float Spacing { get; set; }
+
+		/// <summary>
+		/// Returns the size of a string when rendered in this font.
+		/// </summary>
+		/// <param name="text">The text to measure.</param>
+		/// <returns>The size, in pixels, of 'text' when rendered in
+		/// this font.</returns>
+		public Vector2 MeasureString(string text)
+		{
+			var source = new CharacterSource(text);
+			Vector2 size;
+			MeasureString(ref source, out size);
+			return size;
+		}
+
+		/// <summary>
+		/// Returns the size of the contents of a StringBuilder when
+		/// rendered in this font.
+		/// </summary>
+		/// <param name="text">The text to measure.</param>
+		/// <returns>The size, in pixels, of 'text' when rendered in
+		/// this font.</returns>
+		public Vector2 MeasureString(StringBuilder text)
+		{
+			var source = new CharacterSource(text);
+			Vector2 size;
+			MeasureString(ref source, out size);
+			return size;
+		}
+
+		internal unsafe void MeasureString(ref CharacterSource text, out Vector2 size)
+		{
+			if (text.Length == 0)
+            {
+				size = Vector2.Zero;
+				return;
+			}
+
+			var width = 0.0f;
+			var finalLineHeight = (float)LineSpacing;
+            
+			var offset = Vector2.Zero;
+            var firstGlyphOfLine = true;
+
+            fixed (Glyph* pGlyphs = Glyphs)
+            for (var i = 0; i < text.Length; ++i)
+            {
+                var c = text[i];
+
+                if (c == '\r')
+                    continue;
+
+                if (c == '\n')
+                {
+                    finalLineHeight = LineSpacing;
+
+                    offset.X = 0;
+                    offset.Y += LineSpacing;
+                    firstGlyphOfLine = true;
+                    continue;
+                }
+
+                var currentGlyphIndex = GetGlyphIndexOrDefault(c);
+                Debug.Assert(currentGlyphIndex >= 0 && currentGlyphIndex < Glyphs.Length, "currentGlyphIndex was outside the bounds of the array.");
+                var pCurrentGlyph = pGlyphs + currentGlyphIndex;
+
+                // The first character on a line might have a negative left side bearing.
+                // In this scenario, SpriteBatch/SpriteFont normally offset the text to the right,
+                //  so that text does not hang off the left side of its rectangle.
+                if (firstGlyphOfLine) {
+                    offset.X = Math.Max(pCurrentGlyph->LeftSideBearing, 0);
+                    firstGlyphOfLine = false;
+                } else {
+                    offset.X += Spacing + pCurrentGlyph->LeftSideBearing;
+                }
+
+                offset.X += pCurrentGlyph->Width;
+
+                var proposedWidth = offset.X + Math.Max(pCurrentGlyph->RightSideBearing, 0);
+                if (proposedWidth > width)
+                    width = proposedWidth;
+
+                offset.X += pCurrentGlyph->RightSideBearing;
+
+                if (pCurrentGlyph->Cropping.Height > finalLineHeight)
+                    finalLineHeight = pCurrentGlyph->Cropping.Height;
+            }
+
+            size.X = width;
+            size.Y = offset.Y + finalLineHeight;
+		}
+        
+        internal unsafe bool TryGetGlyphIndex(char c, out int index)
+        {
+            fixed (CharacterRegion* pRegions = _regions)
+            {
+                // Get region Index 
+                int regionIdx = -1;
+                var l = 0;
+                var r = _regions.Length - 1;
+                while (l <= r)
+                {
+                    var m = (l + r) >> 1;                    
+                    Debug.Assert(m >= 0 && m < _regions.Length, "Index was outside the bounds of the array.");
+                    if (pRegions[m].End < c)
+                    {
+                        l = m + 1;
+                    }
+                    else if (pRegions[m].Start > c)
+                    {
+                        r = m - 1;
+                    }
+                    else
+                    {
+                        regionIdx = m;
+                        break;
+                    }
+                }
+
+                if (regionIdx == -1)
+                {
+                    index = -1;
+                    return false;
+                }
+
+                index = pRegions[regionIdx].StartIndex + (c - pRegions[regionIdx].Start);
+            }
+
+            return true;
+        }
+
+        internal int GetGlyphIndexOrDefault(char c)
+        {
+            int glyphIdx;
+            if (!TryGetGlyphIndex(c, out glyphIdx))
+            {
+                if (_defaultGlyphIndex == -1)
+                    throw new ArgumentException(Errors.TextContainsUnresolvableCharacters, "text");
+
+                return _defaultGlyphIndex;
+            }
+            else
+                return glyphIdx;
+        }
+        
+        internal struct CharacterSource 
+        {
+			private readonly string _string;
+			private readonly StringBuilder _builder;
+
+			public CharacterSource(string s)
+			{
+				_string = s;
+				_builder = null;
+				Length = s.Length;
+			}
+
+			public CharacterSource(StringBuilder builder)
+			{
+				_builder = builder;
+				_string = null;
+				Length = _builder.Length;
+			}
+
+			public readonly int Length;
+			public char this [int index] 
+            {
+				get 
+                {
+					if (_string != null)
+						return _string[index];
+					return _builder[index];
+				}
+			}
+		}
+
+        /// <summary>
+        /// Struct that defines the spacing, Kerning, and bounds of a character.
+        /// </summary>
+        /// <remarks>Provides the data necessary to implement custom SpriteFont rendering.</remarks>
+		public struct Glyph 
+        {
+            /// <summary>
+            /// The char associated with this glyph.
+            /// </summary>
+			public char Character;
+            /// <summary>
+            /// Rectangle in the font texture where this letter exists.
+            /// </summary>
+			public Rectangle BoundsInTexture;
+            /// <summary>
+            /// Cropping applied to the BoundsInTexture to calculate the bounds of the actual character.
+            /// </summary>
+			public Rectangle Cropping;
+            /// <summary>
+            /// The amount of space between the left side ofthe character and its first pixel in the X dimention.
+            /// </summary>
+            public float LeftSideBearing;
+            /// <summary>
+            /// The amount of space between the right side of the character and its last pixel in the X dimention.
+            /// </summary>
+            public float RightSideBearing;
+            /// <summary>
+            /// Width of the character before kerning is applied. 
+            /// </summary>
+            public float Width;
+            /// <summary>
+            /// Width of the character before kerning is applied. 
+            /// </summary>
+            public float WidthIncludingBearings;
+
+			public static readonly Glyph Empty = new Glyph();
+
+			public override string ToString ()
+			{
+                return "CharacterIndex=" + Character + ", Glyph=" + BoundsInTexture + ", Cropping=" + Cropping + ", Kerning=" + LeftSideBearing + "," + Width + "," + RightSideBearing;
+			}
+		}
+
+        private struct CharacterRegion
+        {
+            public char Start;
+            public char End;
+            public int StartIndex;
+
+            public CharacterRegion(char start, int startIndex)
+            {
+                this.Start = start;                
+                this.End = start;
+                this.StartIndex = startIndex;
+            }
+        }
+	}
+}
diff --git a/MonoGame.Framework/Graphics/SpriteSortMode.cs b/MonoGame.Framework/Graphics/SpriteSortMode.cs
new file mode 100644
index 00000000000..2b2c0b44a6b
--- /dev/null
+++ b/MonoGame.Framework/Graphics/SpriteSortMode.cs
@@ -0,0 +1,33 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines sprite sort rendering options.
+    /// </summary>
+    public enum SpriteSortMode
+    {
+        /// <summary>
+        /// All sprites are drawing when <see cref="SpriteBatch.End"/> invokes, in order of draw call sequence. Depth is ignored.
+        /// </summary>
+        Deferred,
+        /// <summary>
+        /// Each sprite is drawing at individual draw call, instead of <see cref="SpriteBatch.End"/>. Depth is ignored.
+        /// </summary>
+        Immediate,
+        /// <summary>
+        /// Same as <see cref="SpriteSortMode.Deferred"/>, except sprites are sorted by texture prior to drawing. Depth is ignored.
+        /// </summary>
+        Texture,
+        /// <summary>
+        /// Same as <see cref="SpriteSortMode.Deferred"/>, except sprites are sorted by depth in back-to-front order prior to drawing.
+        /// </summary>
+        BackToFront,
+        /// <summary>
+        /// Same as <see cref="SpriteSortMode.Deferred"/>, except sprites are sorted by depth in front-to-back order prior to drawing.
+        /// </summary>
+        FrontToBack
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/States/Blend.cs b/MonoGame.Framework/Graphics/States/Blend.cs
new file mode 100644
index 00000000000..dd1e02bac85
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/Blend.cs
@@ -0,0 +1,74 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines a blend mode.
+    /// </summary>
+	public enum Blend
+	{
+        /// <summary>
+        /// Each component of the color is multiplied by {1, 1, 1, 1}.
+        /// </summary>
+		One,
+        /// <summary>
+        /// Each component of the color is multiplied by {0, 0, 0, 0}.
+        /// </summary>
+		Zero,
+        /// <summary>
+        /// Each component of the color is multiplied by the source color. 
+        /// {Rs, Gs, Bs, As}, where Rs, Gs, Bs, As are color source values.
+        /// </summary>
+		SourceColor,
+        /// <summary>
+        /// Each component of the color is multiplied by the inverse of the source color.
+        ///  {1 − Rs, 1 − Gs, 1 − Bs, 1 − As}, where Rs, Gs, Bs, As are color source values.
+        /// </summary>
+		InverseSourceColor,
+        /// <summary>
+        /// Each component of the color is multiplied by the alpha value of the source. 
+        /// {As, As, As, As}, where As is the source alpha value.
+        /// </summary>
+		SourceAlpha,
+        /// <summary>
+        /// Each component of the color is multiplied by the inverse of the alpha value of the source. 
+        /// {1 − As, 1 − As, 1 − As, 1 − As}, where As is the source alpha value.
+        /// </summary>
+		InverseSourceAlpha,
+        /// <summary>
+        /// Each component color is multiplied by the destination color. 
+        /// {Rd, Gd, Bd, Ad}, where Rd, Gd, Bd, Ad are color destination values.
+        /// </summary>
+		DestinationColor,	
+        /// <summary>
+        /// Each component of the color is multiplied by the inversed destination color. 
+        /// {1 − Rd, 1 − Gd, 1 − Bd, 1 − Ad}, where Rd, Gd, Bd, Ad are color destination values.
+        /// </summary>
+		InverseDestinationColor,
+        /// <summary>
+        /// Each component of the color is multiplied by the alpha value of the destination.
+        /// {Ad, Ad, Ad, Ad}, where Ad is the destination alpha value.
+        /// </summary>
+		DestinationAlpha,	
+        /// <summary>
+        /// Each component of the color is multiplied by the inversed alpha value of the destination. 
+        /// {1 − Ad, 1 − Ad, 1 − Ad, 1 − Ad}, where Ad is the destination alpha value.
+        /// </summary>
+		InverseDestinationAlpha,
+	    /// <summary>
+        /// Each component of the color is multiplied by a constant in the <see cref="P:Microsoft.Xna.Framework.Graphics.GraphicsDevice.BlendFactor"/>.
+	    /// </summary>
+		BlendFactor,
+        /// <summary>
+        /// Each component of the color is multiplied by a inversed constant in the <see cref="P:Microsoft.Xna.Framework.Graphics.GraphicsDevice.BlendFactor"/>.
+        /// </summary>
+		InverseBlendFactor,
+        /// <summary>
+        /// Each component of the color is multiplied by either the alpha of the source color, or the inverse of the alpha of the source color, whichever is greater. 
+        /// {f, f, f, 1}, where f = min(As, 1 − As), where As is the source alpha value.
+        /// </summary>
+		SourceAlphaSaturation
+	}
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/States/BlendFunction.cs b/MonoGame.Framework/Graphics/States/BlendFunction.cs
new file mode 100644
index 00000000000..04160793822
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/BlendFunction.cs
@@ -0,0 +1,33 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines a function for color blending.
+    /// </summary>
+	public enum BlendFunction
+	{
+        /// <summary>
+        /// The function will adds destination to the source. (srcColor * srcBlend) + (destColor * destBlend)
+        /// </summary>
+		Add,
+        /// <summary>
+        /// The function will subtracts destination from source. (srcColor * srcBlend) − (destColor * destBlend)
+        /// </summary>
+		Subtract,
+        /// <summary>
+        /// The function will subtracts source from destination. (destColor * destBlend) - (srcColor * srcBlend) 
+        /// </summary>
+        ReverseSubtract,
+        /// <summary>
+        /// The function will extracts minimum of the source and destination. min((srcColor * srcBlend),(destColor * destBlend))
+        /// </summary>
+        Min, 
+        /// <summary>
+        /// The function will extracts maximum of the source and destination. max((srcColor * srcBlend),(destColor * destBlend))
+        /// </summary>
+		Max
+	}
+}
diff --git a/MonoGame.Framework/Graphics/States/BlendState.DirectX.cs b/MonoGame.Framework/Graphics/States/BlendState.DirectX.cs
new file mode 100644
index 00000000000..93dbd128d16
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/BlendState.DirectX.cs
@@ -0,0 +1,51 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class BlendState
+    {
+        private SharpDX.Direct3D11.BlendState _state;
+
+        protected internal override void GraphicsDeviceResetting()
+        {
+            SharpDX.Utilities.Dispose(ref _state);
+            base.GraphicsDeviceResetting();
+        }
+
+        internal SharpDX.Direct3D11.BlendState GetDxState(GraphicsDevice device)
+        {
+            if (_state == null)
+            {
+                // Build the description.
+                var desc = new SharpDX.Direct3D11.BlendStateDescription();
+                _targetBlendState[0].GetState(ref desc.RenderTarget[0]);
+                _targetBlendState[1].GetState(ref desc.RenderTarget[1]);
+                _targetBlendState[2].GetState(ref desc.RenderTarget[2]);
+                _targetBlendState[3].GetState(ref desc.RenderTarget[3]);
+                desc.IndependentBlendEnable = _independentBlendEnable;
+
+                // This is a new DX11 feature we should consider 
+                // exposing as part of the extended MonoGame API.
+                desc.AlphaToCoverageEnable = false;
+
+                // Create the state.
+                _state = new SharpDX.Direct3D11.BlendState(GraphicsDevice._d3dDevice, desc);
+            }
+
+            Debug.Assert(GraphicsDevice == device, "The state was created for a different device!");
+
+			// Apply the state!
+			return _state;
+        }
+
+        partial void PlatformDispose()
+        {
+            SharpDX.Utilities.Dispose(ref _state);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/States/BlendState.OpenGL.cs b/MonoGame.Framework/Graphics/States/BlendState.OpenGL.cs
new file mode 100644
index 00000000000..949bc592038
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/BlendState.OpenGL.cs
@@ -0,0 +1,72 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class BlendState
+    {
+        internal void PlatformApplyState(GraphicsDevice device, bool force = false)
+        {
+            var blendEnabled = !(this.ColorSourceBlend == Blend.One && 
+                                 this.ColorDestinationBlend == Blend.Zero &&
+                                 this.AlphaSourceBlend == Blend.One &&
+                                 this.AlphaDestinationBlend == Blend.Zero);
+            if (force || blendEnabled != device._lastBlendEnable)
+            {
+                if (blendEnabled)
+                    GL.Enable(EnableCap.Blend);
+                else
+                    GL.Disable(EnableCap.Blend);
+                GraphicsExtensions.CheckGLError();
+                device._lastBlendEnable = blendEnabled;
+            }
+
+            if (force || 
+                this.ColorBlendFunction != device._lastBlendState.ColorBlendFunction || 
+                this.AlphaBlendFunction != device._lastBlendState.AlphaBlendFunction)
+            {
+                GL.BlendEquationSeparate(
+                    this.ColorBlendFunction.GetBlendEquationMode(),
+                    this.AlphaBlendFunction.GetBlendEquationMode());
+                GraphicsExtensions.CheckGLError();
+                device._lastBlendState.ColorBlendFunction = this.ColorBlendFunction;
+                device._lastBlendState.AlphaBlendFunction = this.AlphaBlendFunction;
+            }
+
+            if (force ||
+                this.ColorSourceBlend != device._lastBlendState.ColorSourceBlend ||
+                this.ColorDestinationBlend != device._lastBlendState.ColorDestinationBlend ||
+                this.AlphaSourceBlend != device._lastBlendState.AlphaSourceBlend ||
+                this.AlphaDestinationBlend != device._lastBlendState.AlphaDestinationBlend)
+            {
+                GL.BlendFuncSeparate(
+                    this.ColorSourceBlend.GetBlendFactorSrc(), 
+                    this.ColorDestinationBlend.GetBlendFactorDest(), 
+                    this.AlphaSourceBlend.GetBlendFactorSrc(), 
+                    this.AlphaDestinationBlend.GetBlendFactorDest());
+                GraphicsExtensions.CheckGLError();
+                device._lastBlendState.ColorSourceBlend = this.ColorSourceBlend;
+                device._lastBlendState.ColorDestinationBlend = this.ColorDestinationBlend;
+                device._lastBlendState.AlphaSourceBlend = this.AlphaSourceBlend;
+                device._lastBlendState.AlphaDestinationBlend = this.AlphaDestinationBlend;
+            }
+
+            if (force || this.ColorWriteChannels != device._lastBlendState.ColorWriteChannels)
+            {
+                GL.ColorMask(
+                    (this.ColorWriteChannels & ColorWriteChannels.Red) != 0,
+                    (this.ColorWriteChannels & ColorWriteChannels.Green) != 0,
+                    (this.ColorWriteChannels & ColorWriteChannels.Blue) != 0,
+                    (this.ColorWriteChannels & ColorWriteChannels.Alpha) != 0);
+                GraphicsExtensions.CheckGLError();
+                device._lastBlendState.ColorWriteChannels = this.ColorWriteChannels;
+            }
+
+            
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/States/BlendState.Web.cs b/MonoGame.Framework/Graphics/States/BlendState.Web.cs
new file mode 100644
index 00000000000..d12a20a4a4c
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/BlendState.Web.cs
@@ -0,0 +1,18 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class BlendState
+    {
+        internal void PlatformApplyState(GraphicsDevice device)
+        {
+            
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/States/BlendState.cs b/MonoGame.Framework/Graphics/States/BlendState.cs
new file mode 100644
index 00000000000..b4379a2fcd1
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/BlendState.cs
@@ -0,0 +1,261 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public partial class BlendState : GraphicsResource
+	{
+        private readonly TargetBlendState[] _targetBlendState;
+
+        private readonly bool _defaultStateObject;
+
+	    private Color _blendFactor;
+
+	    private int _multiSampleMask;
+
+	    private bool _independentBlendEnable;
+
+        internal void BindToGraphicsDevice(GraphicsDevice device)
+        {
+            if (_defaultStateObject)
+                throw new InvalidOperationException("You cannot bind a default state object.");
+            if (GraphicsDevice != null && GraphicsDevice != device)
+                throw new InvalidOperationException("This blend state is already bound to a different graphics device.");
+            GraphicsDevice = device;
+        }
+
+        internal void ThrowIfBound()
+        {
+            if (_defaultStateObject)
+                throw new InvalidOperationException("You cannot modify a default blend state object.");
+            if (GraphicsDevice != null)
+                throw new InvalidOperationException("You cannot modify the blend state after it has been bound to the graphics device!");
+        }
+
+        /// <summary>
+        /// Returns the target specific blend state.
+        /// </summary>
+        /// <param name="index">The 0 to 3 target blend state index.</param>
+        /// <returns>A target blend state.</returns>
+        public TargetBlendState this[int index]
+        {
+            get { return _targetBlendState[index]; }
+        }
+
+	    public BlendFunction AlphaBlendFunction
+	    {
+	        get { return _targetBlendState[0].AlphaBlendFunction; }
+            set
+            {
+                ThrowIfBound();
+                _targetBlendState[0].AlphaBlendFunction = value;
+            }
+	    }
+
+		public Blend AlphaDestinationBlend
+        {
+            get { return _targetBlendState[0].AlphaDestinationBlend; }
+            set
+            {
+                ThrowIfBound();
+                _targetBlendState[0].AlphaDestinationBlend = value;
+            }
+        }
+
+		public Blend AlphaSourceBlend
+        {
+            get { return _targetBlendState[0].AlphaSourceBlend; }
+            set
+            {
+                ThrowIfBound();
+                _targetBlendState[0].AlphaSourceBlend = value;
+            }
+        }
+
+		public BlendFunction ColorBlendFunction
+        {
+            get { return _targetBlendState[0].ColorBlendFunction; }
+            set
+            {
+                ThrowIfBound();
+                _targetBlendState[0].ColorBlendFunction = value;
+            }
+        }
+
+		public Blend ColorDestinationBlend
+        {
+            get { return _targetBlendState[0].ColorDestinationBlend; }
+            set
+            {
+                ThrowIfBound();
+                _targetBlendState[0].ColorDestinationBlend = value;
+            }
+        }
+
+		public Blend ColorSourceBlend
+        {
+            get { return _targetBlendState[0].ColorSourceBlend; }
+            set
+            {
+                ThrowIfBound();
+                _targetBlendState[0].ColorSourceBlend = value;
+            }
+        }
+
+		public ColorWriteChannels ColorWriteChannels
+        {
+            get { return _targetBlendState[0].ColorWriteChannels; }
+            set
+            {
+                ThrowIfBound();
+                _targetBlendState[0].ColorWriteChannels = value;
+            }
+        }
+
+		public ColorWriteChannels ColorWriteChannels1
+        {
+            get { return _targetBlendState[1].ColorWriteChannels; }
+            set
+            {
+                ThrowIfBound();
+                _targetBlendState[1].ColorWriteChannels = value;
+            }
+        }
+
+		public ColorWriteChannels ColorWriteChannels2
+        {
+            get { return _targetBlendState[2].ColorWriteChannels; }
+            set
+            {
+                ThrowIfBound();
+                _targetBlendState[2].ColorWriteChannels = value;
+            }
+        }
+
+		public ColorWriteChannels ColorWriteChannels3
+        {
+            get { return _targetBlendState[3].ColorWriteChannels; }
+            set
+            {
+                ThrowIfBound();
+                _targetBlendState[3].ColorWriteChannels = value;
+            }
+        }
+
+        /// <summary>
+        /// The color used as blend factor when alpha blending.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="P:Microsoft.Xna.Framework.Graphics.GraphicsDevice.BlendFactor"/> is set to this value when this <see cref="BlendState"/>
+        /// is bound to a GraphicsDevice.
+        /// </remarks>
+	    public Color BlendFactor
+	    {
+	        get { return _blendFactor; }
+            set
+            {
+                ThrowIfBound();
+                _blendFactor = value;
+            }
+	    }
+
+        public int MultiSampleMask
+        {
+            get { return _multiSampleMask; }
+            set
+            {
+                ThrowIfBound();
+                _multiSampleMask = value;
+            }
+        }
+
+        /// <summary>
+        /// Enables use of the per-target blend states.
+        /// </summary>
+        public bool IndependentBlendEnable
+        {
+            get { return _independentBlendEnable; }
+            set
+            {
+                ThrowIfBound();
+                _independentBlendEnable = value;
+            }
+        }
+
+
+        public static readonly BlendState Additive;
+        public static readonly BlendState AlphaBlend;
+        public static readonly BlendState NonPremultiplied;
+        public static readonly BlendState Opaque;
+
+        public BlendState()
+        {
+            _targetBlendState = new TargetBlendState[4];
+            _targetBlendState[0] = new TargetBlendState(this);
+            _targetBlendState[1] = new TargetBlendState(this);
+            _targetBlendState[2] = new TargetBlendState(this);
+            _targetBlendState[3] = new TargetBlendState(this);
+
+			_blendFactor = Color.White;
+            _multiSampleMask = Int32.MaxValue;
+            _independentBlendEnable = false;
+        }
+
+        private BlendState(string name, Blend sourceBlend, Blend destinationBlend)
+            : this()
+        {
+            Name = name;
+            ColorSourceBlend = sourceBlend;
+            AlphaSourceBlend = sourceBlend;
+            ColorDestinationBlend = destinationBlend;
+            AlphaDestinationBlend = destinationBlend;
+            _defaultStateObject = true;
+        }
+
+        private BlendState(BlendState cloneSource)
+        {
+            Name = cloneSource.Name;
+
+            _targetBlendState = new TargetBlendState[4];
+            _targetBlendState[0] = cloneSource[0].Clone(this);
+            _targetBlendState[1] = cloneSource[1].Clone(this);
+            _targetBlendState[2] = cloneSource[2].Clone(this);
+            _targetBlendState[3] = cloneSource[3].Clone(this);
+
+            _blendFactor = cloneSource._blendFactor;
+            _multiSampleMask = cloneSource._multiSampleMask;
+            _independentBlendEnable = cloneSource._independentBlendEnable;
+        }
+
+        static BlendState()
+        {
+            Additive = new BlendState("BlendState.Additive", Blend.SourceAlpha, Blend.One);
+            AlphaBlend = new BlendState("BlendState.AlphaBlend", Blend.One, Blend.InverseSourceAlpha);
+            NonPremultiplied = new BlendState("BlendState.NonPremultiplied", Blend.SourceAlpha, Blend.InverseSourceAlpha);
+            Opaque = new BlendState("BlendState.Opaque", Blend.One, Blend.Zero);
+		}
+
+	    internal BlendState Clone()
+	    {
+	        return new BlendState(this);
+	    }
+
+        partial void PlatformDispose();
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                for (int i = 0; i < _targetBlendState.Length; ++i)
+                    _targetBlendState[i] = null;
+
+                PlatformDispose();
+            }
+            base.Dispose(disposing);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/States/CompareFunction.cs b/MonoGame.Framework/Graphics/States/CompareFunction.cs
new file mode 100644
index 00000000000..39dff5e635b
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/CompareFunction.cs
@@ -0,0 +1,45 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// The comparison function used for depth, stencil, and alpha tests.
+    /// </summary>
+    public enum CompareFunction
+    {
+        /// <summary>
+        /// Always passes the test.
+        /// </summary>
+        Always,
+        /// <summary>
+        /// Never passes the test.
+        /// </summary>
+        Never,
+        /// <summary>
+        /// Passes the test when the new pixel value is less than current pixel value.
+        /// </summary>
+        Less,
+        /// <summary>
+        /// Passes the test when the new pixel value is less than or equal to current pixel value.
+        /// </summary>
+        LessEqual,
+        /// <summary>
+        /// Passes the test when the new pixel value is equal to current pixel value.
+        /// </summary>
+        Equal,
+        /// <summary>
+        /// Passes the test when the new pixel value is greater than or equal to current pixel value.
+        /// </summary>
+        GreaterEqual,
+        /// <summary>
+        /// Passes the test when the new pixel value is greater than current pixel value.
+        /// </summary>
+        Greater,
+        /// <summary>
+        /// Passes the test when the new pixel value does not equal to current pixel value.
+        /// </summary>
+        NotEqual
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/States/CullMode.cs b/MonoGame.Framework/Graphics/States/CullMode.cs
new file mode 100644
index 00000000000..c367a79e0d4
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/CullMode.cs
@@ -0,0 +1,25 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines a culling mode for faces in rasterization process.
+    /// </summary>
+    public enum CullMode
+    {
+        /// <summary>
+        /// Do not cull faces.
+        /// </summary>
+        None,
+        /// <summary>
+        /// Cull faces with clockwise order.
+        /// </summary>
+        CullClockwiseFace,
+        /// <summary>
+        /// Cull faces with counter clockwise order.
+        /// </summary>
+        CullCounterClockwiseFace
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/States/DepthFormat.cs b/MonoGame.Framework/Graphics/States/DepthFormat.cs
new file mode 100644
index 00000000000..265d6c84c36
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/DepthFormat.cs
@@ -0,0 +1,29 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	/// <summary>
+	/// Defines formats for depth-stencil buffer.
+	/// </summary>
+    public enum DepthFormat
+    {
+        /// <summary>
+        /// Depth-stencil buffer will not be created.
+        /// </summary>
+		None,
+        /// <summary>
+        /// 16-bit depth buffer.
+        /// </summary>
+		Depth16,
+        /// <summary>
+        /// 24-bit depth buffer. Equivalent of <see cref="DepthFormat.Depth24Stencil8"/> for DirectX platforms.
+        /// </summary>
+		Depth24,
+        /// <summary>
+        /// 32-bit depth-stencil buffer. Where 24-bit depth and 8-bit for stencil used.
+        /// </summary>
+		Depth24Stencil8
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/States/DepthStencilState.DirectX.cs b/MonoGame.Framework/Graphics/States/DepthStencilState.DirectX.cs
new file mode 100644
index 00000000000..6a875bb53d4
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/DepthStencilState.DirectX.cs
@@ -0,0 +1,111 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class DepthStencilState
+    {
+        private SharpDX.Direct3D11.DepthStencilState _state;
+
+        protected internal override void GraphicsDeviceResetting()
+        {
+            SharpDX.Utilities.Dispose(ref _state);
+            base.GraphicsDeviceResetting();
+        }
+
+        internal void PlatformApplyState(GraphicsDevice device)
+        {
+            if (_state == null)
+            {
+                // Build the description.
+                var desc = new SharpDX.Direct3D11.DepthStencilStateDescription();
+
+                desc.IsDepthEnabled = DepthBufferEnable;
+                desc.DepthComparison = DepthBufferFunction.ToComparison();
+
+                if (DepthBufferWriteEnable)
+                    desc.DepthWriteMask = SharpDX.Direct3D11.DepthWriteMask.All;
+                else
+                    desc.DepthWriteMask = SharpDX.Direct3D11.DepthWriteMask.Zero;
+
+                desc.IsStencilEnabled = StencilEnable;
+                desc.StencilReadMask = (byte)StencilMask; // TODO: Should this instead grab the upper 8bits?
+                desc.StencilWriteMask = (byte)StencilWriteMask;
+
+                if (TwoSidedStencilMode)
+                {
+                    desc.BackFace.Comparison = CounterClockwiseStencilFunction.ToComparison();
+                    desc.BackFace.DepthFailOperation = GetStencilOp(CounterClockwiseStencilDepthBufferFail);
+                    desc.BackFace.FailOperation = GetStencilOp(CounterClockwiseStencilFail);
+                    desc.BackFace.PassOperation = GetStencilOp(CounterClockwiseStencilPass);
+                }
+                else
+                {   //use same settings as frontFace 
+                    desc.BackFace.Comparison = StencilFunction.ToComparison();
+                    desc.BackFace.DepthFailOperation = GetStencilOp(StencilDepthBufferFail);
+                    desc.BackFace.FailOperation = GetStencilOp(StencilFail);
+                    desc.BackFace.PassOperation = GetStencilOp(StencilPass);
+                }
+
+                desc.FrontFace.Comparison = StencilFunction.ToComparison();
+                desc.FrontFace.DepthFailOperation = GetStencilOp(StencilDepthBufferFail);
+                desc.FrontFace.FailOperation = GetStencilOp(StencilFail);
+                desc.FrontFace.PassOperation = GetStencilOp(StencilPass);
+
+                // Create the state.
+                _state = new SharpDX.Direct3D11.DepthStencilState(GraphicsDevice._d3dDevice, desc);
+            }
+
+            Debug.Assert(GraphicsDevice == device, "The state was created for a different device!");
+
+            // NOTE: We make the assumption here that the caller has
+            // locked the d3dContext for us to use.
+
+            // Apply the state!
+            device._d3dContext.OutputMerger.SetDepthStencilState(_state, ReferenceStencil);
+        }
+
+        static private SharpDX.Direct3D11.StencilOperation GetStencilOp(StencilOperation op)
+        {
+            switch (op)
+            {
+                case StencilOperation.Decrement:
+                    return SharpDX.Direct3D11.StencilOperation.Decrement;
+
+                case StencilOperation.DecrementSaturation:
+                    return SharpDX.Direct3D11.StencilOperation.DecrementAndClamp;
+
+                case StencilOperation.Increment:
+                    return SharpDX.Direct3D11.StencilOperation.Increment;
+
+                case StencilOperation.IncrementSaturation:
+                    return SharpDX.Direct3D11.StencilOperation.IncrementAndClamp;
+
+                case StencilOperation.Invert:
+                    return SharpDX.Direct3D11.StencilOperation.Invert;
+
+                case StencilOperation.Keep:
+                    return SharpDX.Direct3D11.StencilOperation.Keep;
+
+                case StencilOperation.Replace:
+                    return SharpDX.Direct3D11.StencilOperation.Replace;
+
+                case StencilOperation.Zero:
+                    return SharpDX.Direct3D11.StencilOperation.Zero;
+
+                default:
+                    throw new ArgumentException("Invalid stencil operation!");
+            }
+        }
+
+        partial void PlatformDispose()
+        {
+            SharpDX.Utilities.Dispose(ref _state);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/States/DepthStencilState.OpenGL.cs b/MonoGame.Framework/Graphics/States/DepthStencilState.OpenGL.cs
new file mode 100644
index 00000000000..87ab12849e3
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/DepthStencilState.OpenGL.cs
@@ -0,0 +1,218 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class DepthStencilState
+    {
+        internal void PlatformApplyState(GraphicsDevice device, bool force = false)
+        {
+            if (force || this.DepthBufferEnable != device._lastDepthStencilState.DepthBufferEnable)
+            {
+                if (!DepthBufferEnable)
+                {
+                    GL.Disable(EnableCap.DepthTest);
+                    GraphicsExtensions.CheckGLError();
+                }
+                else
+                {
+                    // enable Depth Buffer
+                    GL.Enable(EnableCap.DepthTest);
+                    GraphicsExtensions.CheckGLError();
+                }
+                device._lastDepthStencilState.DepthBufferEnable = this.DepthBufferEnable;
+            }
+
+            if (force || this.DepthBufferFunction != device._lastDepthStencilState.DepthBufferFunction)
+            {
+                GL.DepthFunc(DepthBufferFunction.GetDepthFunction());
+                GraphicsExtensions.CheckGLError();
+                device._lastDepthStencilState.DepthBufferFunction = this.DepthBufferFunction;
+            }
+
+            if (force || this.DepthBufferWriteEnable != device._lastDepthStencilState.DepthBufferWriteEnable)
+            {
+                GL.DepthMask(DepthBufferWriteEnable);
+                GraphicsExtensions.CheckGLError();
+                device._lastDepthStencilState.DepthBufferWriteEnable = this.DepthBufferWriteEnable;
+            }
+
+            if (force || this.StencilEnable != device._lastDepthStencilState.StencilEnable)
+            {
+                if (!StencilEnable)
+                {
+                    GL.Disable(EnableCap.StencilTest);
+                    GraphicsExtensions.CheckGLError();
+                }
+                else
+                {
+                    // enable Stencil
+                    GL.Enable(EnableCap.StencilTest);
+                    GraphicsExtensions.CheckGLError();
+                }
+                device._lastDepthStencilState.StencilEnable = this.StencilEnable;
+            }
+
+            // set function
+            if (this.TwoSidedStencilMode)
+            {
+                var cullFaceModeFront = StencilFace.Front;
+                var cullFaceModeBack = StencilFace.Back;
+                var stencilFaceFront = StencilFace.Front;
+                var stencilFaceBack = StencilFace.Back;
+
+                if (force ||
+					this.TwoSidedStencilMode != device._lastDepthStencilState.TwoSidedStencilMode ||
+					this.StencilFunction != device._lastDepthStencilState.StencilFunction ||
+					this.ReferenceStencil != device._lastDepthStencilState.ReferenceStencil ||
+					this.StencilMask != device._lastDepthStencilState.StencilMask)
+				{
+                    GL.StencilFuncSeparate(cullFaceModeFront, GetStencilFunc(this.StencilFunction),
+                                           this.ReferenceStencil, this.StencilMask);
+                    GraphicsExtensions.CheckGLError();
+                    device._lastDepthStencilState.StencilFunction = this.StencilFunction;
+                    device._lastDepthStencilState.ReferenceStencil = this.ReferenceStencil;
+                    device._lastDepthStencilState.StencilMask = this.StencilMask;
+                }
+
+                if (force ||
+                    this.TwoSidedStencilMode != device._lastDepthStencilState.TwoSidedStencilMode ||
+                    this.CounterClockwiseStencilFunction != device._lastDepthStencilState.CounterClockwiseStencilFunction ||
+                    this.ReferenceStencil != device._lastDepthStencilState.ReferenceStencil ||
+                    this.StencilMask != device._lastDepthStencilState.StencilMask)
+			    {
+                    GL.StencilFuncSeparate(cullFaceModeBack, GetStencilFunc(this.CounterClockwiseStencilFunction),
+                                           this.ReferenceStencil, this.StencilMask);
+                    GraphicsExtensions.CheckGLError();
+                    device._lastDepthStencilState.CounterClockwiseStencilFunction = this.CounterClockwiseStencilFunction;
+                    device._lastDepthStencilState.ReferenceStencil = this.ReferenceStencil;
+                    device._lastDepthStencilState.StencilMask = this.StencilMask;
+                }
+
+                
+                if (force ||
+					this.TwoSidedStencilMode != device._lastDepthStencilState.TwoSidedStencilMode ||
+					this.StencilFail != device._lastDepthStencilState.StencilFail ||
+					this.StencilDepthBufferFail != device._lastDepthStencilState.StencilDepthBufferFail ||
+					this.StencilPass != device._lastDepthStencilState.StencilPass)
+                {
+                    GL.StencilOpSeparate(stencilFaceFront, GetStencilOp(this.StencilFail),
+                                         GetStencilOp(this.StencilDepthBufferFail),
+                                         GetStencilOp(this.StencilPass));
+                    GraphicsExtensions.CheckGLError();
+                    device._lastDepthStencilState.StencilFail = this.StencilFail;
+                    device._lastDepthStencilState.StencilDepthBufferFail = this.StencilDepthBufferFail;
+                    device._lastDepthStencilState.StencilPass = this.StencilPass;
+                }
+
+                if (force ||
+                    this.TwoSidedStencilMode != device._lastDepthStencilState.TwoSidedStencilMode ||
+                    this.CounterClockwiseStencilFail != device._lastDepthStencilState.CounterClockwiseStencilFail ||
+                    this.CounterClockwiseStencilDepthBufferFail != device._lastDepthStencilState.CounterClockwiseStencilDepthBufferFail ||
+                    this.CounterClockwiseStencilPass != device._lastDepthStencilState.CounterClockwiseStencilPass)
+			    {
+                    GL.StencilOpSeparate(stencilFaceBack, GetStencilOp(this.CounterClockwiseStencilFail),
+                                         GetStencilOp(this.CounterClockwiseStencilDepthBufferFail),
+                                         GetStencilOp(this.CounterClockwiseStencilPass));
+                    GraphicsExtensions.CheckGLError();
+                    device._lastDepthStencilState.CounterClockwiseStencilFail = this.CounterClockwiseStencilFail;
+                    device._lastDepthStencilState.CounterClockwiseStencilDepthBufferFail = this.CounterClockwiseStencilDepthBufferFail;
+                    device._lastDepthStencilState.CounterClockwiseStencilPass = this.CounterClockwiseStencilPass;
+                }
+            }
+            else
+            {
+                if (force ||
+					this.TwoSidedStencilMode != device._lastDepthStencilState.TwoSidedStencilMode ||
+					this.StencilFunction != device._lastDepthStencilState.StencilFunction ||
+					this.ReferenceStencil != device._lastDepthStencilState.ReferenceStencil ||
+					this.StencilMask != device._lastDepthStencilState.StencilMask)
+				{
+                    GL.StencilFunc(GetStencilFunc(this.StencilFunction), ReferenceStencil, StencilMask);
+                    GraphicsExtensions.CheckGLError();
+                    device._lastDepthStencilState.StencilFunction = this.StencilFunction;
+                    device._lastDepthStencilState.ReferenceStencil = this.ReferenceStencil;
+                    device._lastDepthStencilState.StencilMask = this.StencilMask;
+                }
+
+                if (force ||
+                    this.TwoSidedStencilMode != device._lastDepthStencilState.TwoSidedStencilMode ||
+                    this.StencilFail != device._lastDepthStencilState.StencilFail ||
+                    this.StencilDepthBufferFail != device._lastDepthStencilState.StencilDepthBufferFail ||
+                    this.StencilPass != device._lastDepthStencilState.StencilPass)
+                {
+                    GL.StencilOp(GetStencilOp(StencilFail),
+                                 GetStencilOp(StencilDepthBufferFail),
+                                 GetStencilOp(StencilPass));
+                    GraphicsExtensions.CheckGLError();
+                    device._lastDepthStencilState.StencilFail = this.StencilFail;
+                    device._lastDepthStencilState.StencilDepthBufferFail = this.StencilDepthBufferFail;
+                    device._lastDepthStencilState.StencilPass = this.StencilPass;
+                }
+            }
+
+            device._lastDepthStencilState.TwoSidedStencilMode = this.TwoSidedStencilMode;
+
+            if (force || this.StencilWriteMask != device._lastDepthStencilState.StencilWriteMask)
+            {
+                GL.StencilMask(this.StencilWriteMask);
+                GraphicsExtensions.CheckGLError();
+                device._lastDepthStencilState.StencilWriteMask = this.StencilWriteMask;
+            }
+        }
+
+        private static GLStencilFunction GetStencilFunc(CompareFunction function)
+        {
+            switch (function)
+            {
+                case CompareFunction.Always: 
+                    return GLStencilFunction.Always;
+                case CompareFunction.Equal:
+                    return GLStencilFunction.Equal;
+                case CompareFunction.Greater:
+                    return GLStencilFunction.Greater;
+                case CompareFunction.GreaterEqual:
+                    return GLStencilFunction.Gequal;
+                case CompareFunction.Less:
+                    return GLStencilFunction.Less;
+                case CompareFunction.LessEqual:
+                    return GLStencilFunction.Lequal;
+                case CompareFunction.Never:
+                    return GLStencilFunction.Never;
+                case CompareFunction.NotEqual:
+                    return GLStencilFunction.Notequal;
+                default:
+                    return GLStencilFunction.Always;
+            }
+        }
+
+        private static StencilOp GetStencilOp(StencilOperation operation)
+        {
+            switch (operation)
+            {
+                case StencilOperation.Keep:
+                    return StencilOp.Keep;
+                case StencilOperation.Decrement:
+                    return StencilOp.DecrWrap;
+                case StencilOperation.DecrementSaturation:
+                    return StencilOp.Decr;
+                case StencilOperation.IncrementSaturation:
+                    return StencilOp.Incr;
+                case StencilOperation.Increment:
+                    return StencilOp.IncrWrap;
+                case StencilOperation.Invert:
+                    return StencilOp.Invert;
+                case StencilOperation.Replace:
+                    return StencilOp.Replace;
+                case StencilOperation.Zero:
+                    return StencilOp.Zero;
+                default:
+                    return StencilOp.Keep;
+            }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/States/DepthStencilState.Web.cs b/MonoGame.Framework/Graphics/States/DepthStencilState.Web.cs
new file mode 100644
index 00000000000..d2f330f8048
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/DepthStencilState.Web.cs
@@ -0,0 +1,17 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class DepthStencilState
+    {
+        internal void PlatformApplyState(GraphicsDevice device)
+        {
+            
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/States/DepthStencilState.cs b/MonoGame.Framework/Graphics/States/DepthStencilState.cs
new file mode 100644
index 00000000000..a0e33a7b6d1
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/DepthStencilState.cs
@@ -0,0 +1,285 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class DepthStencilState : GraphicsResource
+    {
+        private readonly bool _defaultStateObject;
+
+        private bool _depthBufferEnable;
+        private bool _depthBufferWriteEnable;
+        private StencilOperation _counterClockwiseStencilDepthBufferFail;
+        private StencilOperation _counterClockwiseStencilFail;
+        private CompareFunction _counterClockwiseStencilFunction;
+        private StencilOperation _counterClockwiseStencilPass;
+        private CompareFunction _depthBufferFunction;
+        private int _referenceStencil;
+        private StencilOperation _stencilDepthBufferFail;
+        private bool _stencilEnable;
+        private StencilOperation _stencilFail;
+        private CompareFunction _stencilFunction;
+        private int _stencilMask;
+        private StencilOperation _stencilPass;
+        private int _stencilWriteMask;
+        private bool _twoSidedStencilMode;
+
+        public bool DepthBufferEnable
+        {
+            get { return _depthBufferEnable; }
+            set
+            {
+                ThrowIfBound();
+                _depthBufferEnable = value;
+            }
+        }
+
+        public bool DepthBufferWriteEnable
+        {
+            get { return _depthBufferWriteEnable; }
+            set
+            {
+                ThrowIfBound();
+                _depthBufferWriteEnable = value;
+            }
+        }
+
+        public StencilOperation CounterClockwiseStencilDepthBufferFail
+        {
+            get { return _counterClockwiseStencilDepthBufferFail; }
+            set
+            {
+                ThrowIfBound();
+                _counterClockwiseStencilDepthBufferFail = value;
+            }
+        }
+
+        public StencilOperation CounterClockwiseStencilFail
+        {
+            get { return _counterClockwiseStencilFail; }
+            set
+            {
+                ThrowIfBound();
+                _counterClockwiseStencilFail = value;
+            }
+        }
+
+        public CompareFunction CounterClockwiseStencilFunction
+        {
+            get { return _counterClockwiseStencilFunction; }
+            set
+            {
+                ThrowIfBound();
+                _counterClockwiseStencilFunction = value;
+            }
+        }
+
+        public StencilOperation CounterClockwiseStencilPass
+        {
+            get { return _counterClockwiseStencilPass; }
+            set
+            {
+                ThrowIfBound();
+                _counterClockwiseStencilPass = value;
+            }
+        }
+
+        public CompareFunction DepthBufferFunction
+        {
+            get { return _depthBufferFunction; }
+            set
+            {
+                ThrowIfBound();
+                _depthBufferFunction = value;
+            }
+        }
+
+        public int ReferenceStencil
+        {
+            get { return _referenceStencil; }
+            set
+            {
+                ThrowIfBound();
+                _referenceStencil = value;
+            }
+        }
+
+        public StencilOperation StencilDepthBufferFail
+        {
+            get { return _stencilDepthBufferFail; }
+            set
+            {
+                ThrowIfBound();
+                _stencilDepthBufferFail = value;
+            }
+        }
+
+        public bool StencilEnable
+        {
+            get { return _stencilEnable; }
+            set
+            {
+                ThrowIfBound();
+                _stencilEnable = value;
+            }
+        }
+
+        public StencilOperation StencilFail
+        {
+            get { return _stencilFail; }
+            set
+            {
+                ThrowIfBound();
+                _stencilFail = value;
+            }
+        }
+
+        public CompareFunction StencilFunction
+        {
+            get { return _stencilFunction; }
+            set
+            {
+                ThrowIfBound();
+                _stencilFunction = value;
+            }
+        }
+
+        public int StencilMask
+        {
+            get { return _stencilMask; }
+            set
+            {
+                ThrowIfBound();
+                _stencilMask = value;
+            }
+        }
+
+        public StencilOperation StencilPass
+        {
+            get { return _stencilPass; }
+            set
+            {
+                ThrowIfBound();
+                _stencilPass = value;
+            }
+        }
+
+        public int StencilWriteMask
+        {
+            get { return _stencilWriteMask; }
+            set
+            {
+                ThrowIfBound();
+                _stencilWriteMask = value;
+            }
+        }
+
+        public bool TwoSidedStencilMode
+        {
+            get { return _twoSidedStencilMode; }
+            set
+            {
+                ThrowIfBound();
+                _twoSidedStencilMode = value;
+            }
+        }
+
+        internal void BindToGraphicsDevice(GraphicsDevice device)
+        {
+            if (_defaultStateObject)
+                throw new InvalidOperationException("You cannot bind a default state object.");
+            if (GraphicsDevice != null && GraphicsDevice != device)
+                throw new InvalidOperationException("This depth stencil state is already bound to a different graphics device.");
+            GraphicsDevice = device;
+        }
+
+        internal void ThrowIfBound()
+        {
+            if (_defaultStateObject)
+                throw new InvalidOperationException("You cannot modify a default depth stencil state object.");
+            if (GraphicsDevice != null)
+                throw new InvalidOperationException("You cannot modify the depth stencil state after it has been bound to the graphics device!");
+        }
+
+        public DepthStencilState ()
+		{
+            DepthBufferEnable = true;
+            DepthBufferWriteEnable = true;
+			DepthBufferFunction = CompareFunction.LessEqual;
+			StencilEnable = false;
+			StencilFunction = CompareFunction.Always;
+			StencilPass = StencilOperation.Keep;
+			StencilFail = StencilOperation.Keep;
+			StencilDepthBufferFail = StencilOperation.Keep;
+			TwoSidedStencilMode = false;
+			CounterClockwiseStencilFunction = CompareFunction.Always;
+			CounterClockwiseStencilFail = StencilOperation.Keep;
+			CounterClockwiseStencilPass = StencilOperation.Keep;
+			CounterClockwiseStencilDepthBufferFail = StencilOperation.Keep;
+			StencilMask = Int32.MaxValue;
+			StencilWriteMask = Int32.MaxValue;
+			ReferenceStencil = 0;
+		}
+
+        private DepthStencilState(string name, bool depthBufferEnable, bool depthBufferWriteEnable)
+            : this()
+	    {
+	        Name = name;
+            _depthBufferEnable = depthBufferEnable;
+            _depthBufferWriteEnable = depthBufferWriteEnable;
+	        _defaultStateObject = true;
+	    }
+
+        private DepthStencilState(DepthStencilState cloneSource)
+	    {
+	        Name = cloneSource.Name;
+            _depthBufferEnable = cloneSource._depthBufferEnable;
+            _depthBufferWriteEnable = cloneSource._depthBufferWriteEnable;
+            _counterClockwiseStencilDepthBufferFail = cloneSource._counterClockwiseStencilDepthBufferFail;
+            _counterClockwiseStencilFail = cloneSource._counterClockwiseStencilFail;
+            _counterClockwiseStencilFunction = cloneSource._counterClockwiseStencilFunction;
+            _counterClockwiseStencilPass = cloneSource._counterClockwiseStencilPass;
+            _depthBufferFunction = cloneSource._depthBufferFunction;
+            _referenceStencil = cloneSource._referenceStencil;
+            _stencilDepthBufferFail = cloneSource._stencilDepthBufferFail;
+            _stencilEnable = cloneSource._stencilEnable;
+            _stencilFail = cloneSource._stencilFail;
+            _stencilFunction = cloneSource._stencilFunction;
+            _stencilMask = cloneSource._stencilMask;
+            _stencilPass = cloneSource._stencilPass;
+            _stencilWriteMask = cloneSource._stencilWriteMask;
+            _twoSidedStencilMode = cloneSource._twoSidedStencilMode;
+	    }
+
+        public static readonly DepthStencilState Default;
+        public static readonly DepthStencilState DepthRead;
+        public static readonly DepthStencilState None;
+
+		static DepthStencilState ()
+		{
+		    Default = new DepthStencilState("DepthStencilState.Default", true, true);
+			DepthRead = new DepthStencilState("DepthStencilState.DepthRead", true, false);
+		    None = new DepthStencilState("DepthStencilState.None", false, false);
+		}
+
+        internal DepthStencilState Clone()
+        {
+            return new DepthStencilState(this);
+        }
+
+        partial void PlatformDispose();
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                PlatformDispose();
+            }
+            base.Dispose(disposing);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/States/FillMode.cs b/MonoGame.Framework/Graphics/States/FillMode.cs
new file mode 100644
index 00000000000..b6cfb32922b
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/FillMode.cs
@@ -0,0 +1,21 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines options for filling the primitive.
+    /// </summary>
+    public enum FillMode
+    {
+        /// <summary>
+        /// Draw solid faces for each primitive.
+        /// </summary>
+        Solid,
+        /// <summary>
+        /// Draw lines for each primitive.
+        /// </summary>
+        WireFrame
+    }
+}
diff --git a/MonoGame.Framework/Graphics/States/RasterizerState.DirectX.cs b/MonoGame.Framework/Graphics/States/RasterizerState.DirectX.cs
new file mode 100644
index 00000000000..a8d050a6a5a
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/RasterizerState.DirectX.cs
@@ -0,0 +1,100 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class RasterizerState
+    {
+        private SharpDX.Direct3D11.RasterizerState _state;
+
+        protected internal override void GraphicsDeviceResetting()
+        {
+            SharpDX.Utilities.Dispose(ref _state);
+            base.GraphicsDeviceResetting();
+        }
+
+        internal void PlatformApplyState(GraphicsDevice device)
+        {
+            if (_state == null)
+            {
+                // Build the description.
+                var desc = new SharpDX.Direct3D11.RasterizerStateDescription();
+
+                switch ( CullMode )
+                {
+                    case Graphics.CullMode.CullClockwiseFace:
+                        desc.CullMode = SharpDX.Direct3D11.CullMode.Front;
+                        break;
+
+                    case Graphics.CullMode.CullCounterClockwiseFace:
+                        desc.CullMode = SharpDX.Direct3D11.CullMode.Back;
+                        break;
+
+                    case Graphics.CullMode.None:
+                        desc.CullMode = SharpDX.Direct3D11.CullMode.None;
+                        break;
+                }
+
+                desc.IsScissorEnabled = ScissorTestEnable;
+                desc.IsMultisampleEnabled = MultiSampleAntiAlias;
+
+                // discussion and explanation in https://github.com/MonoGame/MonoGame/issues/4826
+                int depthMul;
+                switch (device.ActiveDepthFormat)
+                {
+                    case DepthFormat.None:
+                        depthMul = 0;
+                        break;
+                    case DepthFormat.Depth16:
+                        depthMul = 1 << 16 - 1;
+                        break;
+                    case DepthFormat.Depth24:
+                    case DepthFormat.Depth24Stencil8:
+                        depthMul = 1 << 24 - 1;
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+
+                desc.DepthBias = (int) (DepthBias * depthMul);
+                desc.SlopeScaledDepthBias = SlopeScaleDepthBias;
+
+                if (FillMode == Graphics.FillMode.WireFrame)
+                    desc.FillMode = SharpDX.Direct3D11.FillMode.Wireframe;
+                else
+                    desc.FillMode = SharpDX.Direct3D11.FillMode.Solid;
+
+                desc.IsDepthClipEnabled = DepthClipEnable;
+
+                // These are new DX11 features we should consider exposing
+                // as part of the extended MonoGame API.
+                desc.IsFrontCounterClockwise = false;
+                desc.IsAntialiasedLineEnabled = false;
+
+                // To support feature level 9.1 these must 
+                // be set to these exact values.
+                desc.DepthBiasClamp = 0.0f;
+
+                // Create the state.
+                _state = new SharpDX.Direct3D11.RasterizerState(GraphicsDevice._d3dDevice, desc);
+            }
+
+            Debug.Assert(GraphicsDevice == device, "The state was created for a different device!");
+
+            // NOTE: We make the assumption here that the caller has
+            // locked the d3dContext for us to use.
+
+            // Apply the state!
+            device._d3dContext.Rasterizer.State = _state;
+        }
+
+        partial void PlatformDispose()
+        {
+            SharpDX.Utilities.Dispose(ref _state);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/States/RasterizerState.OpenGL.cs b/MonoGame.Framework/Graphics/States/RasterizerState.OpenGL.cs
new file mode 100644
index 00000000000..1c60a664330
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/RasterizerState.OpenGL.cs
@@ -0,0 +1,122 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class RasterizerState
+    {
+        internal void PlatformApplyState(GraphicsDevice device, bool force = false)
+        {
+            // When rendering offscreen the faces change order.
+            var offscreen = device.IsRenderTargetBound;
+
+            if (force)
+            {
+                // Turn off dithering to make sure data returned by Texture.GetData is accurate
+                GL.Disable(EnableCap.Dither);
+            }
+
+            if (CullMode == CullMode.None)
+            {
+                GL.Disable(EnableCap.CullFace);
+                GraphicsExtensions.CheckGLError();
+            }
+            else
+            {
+                GL.Enable(EnableCap.CullFace);
+                GraphicsExtensions.CheckGLError();
+                GL.CullFace(CullFaceMode.Back);
+                GraphicsExtensions.CheckGLError();
+
+                if (CullMode == CullMode.CullClockwiseFace)
+                {
+                    if (offscreen)
+                        GL.FrontFace(FrontFaceDirection.Cw);
+                    else
+                        GL.FrontFace(FrontFaceDirection.Ccw);
+                    GraphicsExtensions.CheckGLError();
+                }
+                else
+                {
+                    if (offscreen)
+                        GL.FrontFace(FrontFaceDirection.Ccw);
+                    else
+                        GL.FrontFace(FrontFaceDirection.Cw);
+                    GraphicsExtensions.CheckGLError();
+                }
+            }
+
+#if WINDOWS || DESKTOPGL
+			if (FillMode == FillMode.Solid) 
+				GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
+            else
+				GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
+#else
+            if (FillMode != FillMode.Solid)
+                throw new NotImplementedException();
+#endif
+
+            if (force || this.ScissorTestEnable != device._lastRasterizerState.ScissorTestEnable)
+			{
+			    if (ScissorTestEnable)
+				    GL.Enable(EnableCap.ScissorTest);
+			    else
+				    GL.Disable(EnableCap.ScissorTest);
+                GraphicsExtensions.CheckGLError();
+                device._lastRasterizerState.ScissorTestEnable = this.ScissorTestEnable;
+            }
+
+            if (force || 
+                this.DepthBias != device._lastRasterizerState.DepthBias ||
+                this.SlopeScaleDepthBias != device._lastRasterizerState.SlopeScaleDepthBias)
+            {
+                if (this.DepthBias != 0 || this.SlopeScaleDepthBias != 0)
+                {
+                    // from the docs it seems this works the same as for Direct3D
+                    // https://www.khronos.org/opengles/sdk/docs/man/xhtml/glPolygonOffset.xml
+                    // explanation for Direct3D is  in https://github.com/MonoGame/MonoGame/issues/4826
+                    int depthMul;
+                    switch (device.ActiveDepthFormat)
+                    {
+                        case DepthFormat.None:
+                            depthMul = 0;
+                            break;
+                        case DepthFormat.Depth16:
+                            depthMul = 1 << 16 - 1;
+                            break;
+                        case DepthFormat.Depth24:
+                        case DepthFormat.Depth24Stencil8:
+                            depthMul = 1 << 24 - 1;
+                            break;
+                        default:
+                            throw new ArgumentOutOfRangeException();
+    }
+                    GL.Enable(EnableCap.PolygonOffsetFill);
+                    GL.PolygonOffset(this.SlopeScaleDepthBias, this.DepthBias * depthMul);
+                }
+                else
+                    GL.Disable(EnableCap.PolygonOffsetFill);
+                GraphicsExtensions.CheckGLError();
+                device._lastRasterizerState.DepthBias = this.DepthBias;
+                device._lastRasterizerState.SlopeScaleDepthBias = this.SlopeScaleDepthBias;
+            }
+
+            if (device.GraphicsCapabilities.SupportsDepthClamp &&
+                (force || this.DepthClipEnable != device._lastRasterizerState.DepthClipEnable))
+            {
+                if (!DepthClipEnable)
+                    GL.Enable((EnableCap) 0x864F); // should be EnableCap.DepthClamp, but not available in OpenTK.Graphics.ES20.EnableCap
+                else
+                    GL.Disable((EnableCap) 0x864F);
+                GraphicsExtensions.CheckGLError();
+                device._lastRasterizerState.DepthClipEnable = this.DepthClipEnable;
+            }
+
+            // TODO: Implement MultiSampleAntiAlias
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/States/RasterizerState.Web.cs b/MonoGame.Framework/Graphics/States/RasterizerState.Web.cs
new file mode 100644
index 00000000000..3914aaf502f
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/RasterizerState.Web.cs
@@ -0,0 +1,16 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class RasterizerState
+    {
+        internal void PlatformApplyState(GraphicsDevice device)
+        {
+            
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/States/RasterizerState.cs b/MonoGame.Framework/Graphics/States/RasterizerState.cs
new file mode 100644
index 00000000000..7c44214f12d
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/RasterizerState.cs
@@ -0,0 +1,166 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public partial class RasterizerState : GraphicsResource
+	{
+        private readonly bool _defaultStateObject;
+
+        private CullMode _cullMode;
+        private float _depthBias;
+        private FillMode _fillMode;
+        private bool _multiSampleAntiAlias;
+        private bool _scissorTestEnable;
+        private float _slopeScaleDepthBias;
+        private bool _depthClipEnable;
+
+        public CullMode CullMode
+	    {
+	        get { return _cullMode; }
+            set
+            {
+                ThrowIfBound();
+                _cullMode = value;
+            }
+	    }
+
+	    public float DepthBias
+	    {
+	        get { return _depthBias; }
+	        set
+	        {
+                ThrowIfBound();
+                _depthBias = value;
+	        }
+	    }
+
+	    public FillMode FillMode
+	    {
+	        get { return _fillMode; }
+	        set
+	        {
+                ThrowIfBound();
+                _fillMode = value;
+	        }
+	    }
+
+	    public bool MultiSampleAntiAlias
+	    {
+	        get { return _multiSampleAntiAlias; }
+	        set
+	        {
+                ThrowIfBound();
+                _multiSampleAntiAlias = value;
+	        }
+	    }
+
+	    public bool ScissorTestEnable
+	    {
+	        get { return _scissorTestEnable; }
+	        set
+	        {
+                ThrowIfBound();
+                _scissorTestEnable = value;
+	        }
+	    }
+
+	    public float SlopeScaleDepthBias
+	    {
+	        get { return _slopeScaleDepthBias; }
+	        set
+	        {
+                ThrowIfBound();
+                _slopeScaleDepthBias = value;
+	        }
+	    }
+
+        public bool DepthClipEnable
+        {
+            get { return _depthClipEnable; }
+            set
+            {
+                ThrowIfBound();
+                _depthClipEnable = value;
+            }
+        }
+
+        internal void BindToGraphicsDevice(GraphicsDevice device)
+        {
+            if (_defaultStateObject)
+                throw new InvalidOperationException("You cannot bind a default state object.");
+            if (GraphicsDevice != null && GraphicsDevice != device)
+                throw new InvalidOperationException("This rasterizer state is already bound to a different graphics device.");
+            GraphicsDevice = device;
+        }
+
+        internal void ThrowIfBound()
+        {
+            if (_defaultStateObject)
+                throw new InvalidOperationException("You cannot modify a default rasterizer state object.");
+            if (GraphicsDevice != null)
+                throw new InvalidOperationException("You cannot modify the rasterizer state after it has been bound to the graphics device!");
+        }
+
+	    public static readonly RasterizerState CullClockwise;
+        public static readonly RasterizerState CullCounterClockwise;
+        public static readonly RasterizerState CullNone;
+
+        public RasterizerState()
+		{
+			CullMode = CullMode.CullCounterClockwiseFace;
+			FillMode = FillMode.Solid;
+			DepthBias = 0;
+			MultiSampleAntiAlias = true;
+			ScissorTestEnable = false;
+			SlopeScaleDepthBias = 0;
+            DepthClipEnable = true;
+		}
+
+	    private RasterizerState(string name, CullMode cullMode)
+            : this()
+	    {
+	        Name = name;
+	        _cullMode = cullMode;
+	        _defaultStateObject = true;
+	    }
+
+	    private RasterizerState(RasterizerState cloneSource)
+	    {
+	        Name = cloneSource.Name;
+	        _cullMode = cloneSource._cullMode;
+	        _fillMode = cloneSource._fillMode;
+	        _depthBias = cloneSource._depthBias;
+	        _multiSampleAntiAlias = cloneSource._multiSampleAntiAlias;
+	        _scissorTestEnable = cloneSource._scissorTestEnable;
+	        _slopeScaleDepthBias = cloneSource._slopeScaleDepthBias;
+	        _depthClipEnable = cloneSource._depthClipEnable;
+	    }
+
+		static RasterizerState ()
+		{
+		    CullClockwise = new RasterizerState("RasterizerState.CullClockwise", CullMode.CullClockwiseFace);
+		    CullCounterClockwise = new RasterizerState("RasterizerState.CullCounterClockwise", CullMode.CullCounterClockwiseFace);
+		    CullNone = new RasterizerState("RasterizerState.CullNone", CullMode.None);
+		}
+
+	    internal RasterizerState Clone()
+	    {
+	        return new RasterizerState(this);
+	    }
+
+        partial void PlatformDispose();
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                PlatformDispose();
+            }
+            base.Dispose(disposing);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/States/SamplerState.DirectX.cs b/MonoGame.Framework/Graphics/States/SamplerState.DirectX.cs
new file mode 100644
index 00000000000..e47246eb112
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/SamplerState.DirectX.cs
@@ -0,0 +1,163 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class SamplerState
+    {
+        private SharpDX.Direct3D11.SamplerState _state;
+
+        protected internal override void GraphicsDeviceResetting()
+        {
+            SharpDX.Utilities.Dispose(ref _state);
+            base.GraphicsDeviceResetting();
+        }
+
+        internal SharpDX.Direct3D11.SamplerState GetState(GraphicsDevice device)
+        {
+            if (_state == null)
+            {
+                // Build the description.
+                var desc = new SharpDX.Direct3D11.SamplerStateDescription();
+
+                desc.AddressU = GetAddressMode(AddressU);
+                desc.AddressV = GetAddressMode(AddressV);
+                desc.AddressW = GetAddressMode(AddressW);
+
+#if WINDOWS_UAP
+				desc.BorderColor = new SharpDX.Mathematics.Interop.RawColor4(
+					BorderColor.R / 255.0f,
+					BorderColor.G / 255.0f,
+					BorderColor.B / 255.0f,
+					BorderColor.A / 255.0f);
+#else
+				desc.BorderColor = BorderColor.ToColor4();
+#endif
+				desc.Filter = GetFilter(Filter, FilterMode);
+                desc.MaximumAnisotropy = Math.Min(MaxAnisotropy, device.GraphicsCapabilities.MaxTextureAnisotropy);
+                desc.MipLodBias = MipMapLevelOfDetailBias;
+                desc.ComparisonFunction = ComparisonFunction.ToComparison();
+
+                // TODO: How do i do this?
+                desc.MinimumLod = 0.0f;
+
+                // To support feature level 9.1 these must 
+                // be set to these exact values.
+                desc.MaximumLod = float.MaxValue;
+
+                // Create the state.
+                _state = new SharpDX.Direct3D11.SamplerState(GraphicsDevice._d3dDevice, desc);
+            }
+
+            Debug.Assert(GraphicsDevice == device, "The state was created for a different device!");
+
+            return _state;
+        }
+
+        private static SharpDX.Direct3D11.Filter GetFilter(TextureFilter filter, TextureFilterMode mode)
+        {
+            switch (mode)
+            {
+                case TextureFilterMode.Comparison:
+                    switch (filter)
+                    {
+                        case TextureFilter.Anisotropic:
+                            return SharpDX.Direct3D11.Filter.ComparisonAnisotropic;
+
+                        case TextureFilter.Linear:
+                            return SharpDX.Direct3D11.Filter.ComparisonMinMagMipLinear;
+
+                        case TextureFilter.LinearMipPoint:
+                            return SharpDX.Direct3D11.Filter.ComparisonMinMagLinearMipPoint;
+
+                        case TextureFilter.MinLinearMagPointMipLinear:
+                            return SharpDX.Direct3D11.Filter.ComparisonMinLinearMagPointMipLinear;
+
+                        case TextureFilter.MinLinearMagPointMipPoint:
+                            return SharpDX.Direct3D11.Filter.ComparisonMinLinearMagMipPoint;
+
+                        case TextureFilter.MinPointMagLinearMipLinear:
+                            return SharpDX.Direct3D11.Filter.ComparisonMinPointMagMipLinear;
+
+                        case TextureFilter.MinPointMagLinearMipPoint:
+                            return SharpDX.Direct3D11.Filter.ComparisonMinPointMagLinearMipPoint;
+
+                        case TextureFilter.Point:
+                            return SharpDX.Direct3D11.Filter.ComparisonMinMagMipPoint;
+
+                        case TextureFilter.PointMipLinear:
+                            return SharpDX.Direct3D11.Filter.ComparisonMinMagPointMipLinear;
+
+                        default:
+                            throw new ArgumentException("Invalid texture filter!");
+                    }
+                case TextureFilterMode.Default:
+                    switch (filter)
+                    {
+                        case TextureFilter.Anisotropic:
+                            return SharpDX.Direct3D11.Filter.Anisotropic;
+
+                        case TextureFilter.Linear:
+                            return SharpDX.Direct3D11.Filter.MinMagMipLinear;
+
+                        case TextureFilter.LinearMipPoint:
+                            return SharpDX.Direct3D11.Filter.MinMagLinearMipPoint;
+
+                        case TextureFilter.MinLinearMagPointMipLinear:
+                            return SharpDX.Direct3D11.Filter.MinLinearMagPointMipLinear;
+
+                        case TextureFilter.MinLinearMagPointMipPoint:
+                            return SharpDX.Direct3D11.Filter.MinLinearMagMipPoint;
+
+                        case TextureFilter.MinPointMagLinearMipLinear:
+                            return SharpDX.Direct3D11.Filter.MinPointMagMipLinear;
+
+                        case TextureFilter.MinPointMagLinearMipPoint:
+                            return SharpDX.Direct3D11.Filter.MinPointMagLinearMipPoint;
+
+                        case TextureFilter.Point:
+                            return SharpDX.Direct3D11.Filter.MinMagMipPoint;
+
+                        case TextureFilter.PointMipLinear:
+                            return SharpDX.Direct3D11.Filter.MinMagPointMipLinear;
+
+                        default:
+                            throw new ArgumentException("Invalid texture filter!");
+                    }
+                default:
+                    throw new ArgumentException("Invalid texture filter mode!");
+            }
+        }
+
+        private static SharpDX.Direct3D11.TextureAddressMode GetAddressMode(TextureAddressMode mode)
+        {
+            switch (mode)
+            {
+                case TextureAddressMode.Clamp:
+                    return SharpDX.Direct3D11.TextureAddressMode.Clamp;
+
+                case TextureAddressMode.Mirror:
+                    return SharpDX.Direct3D11.TextureAddressMode.Mirror;
+
+                case TextureAddressMode.Wrap:
+                    return SharpDX.Direct3D11.TextureAddressMode.Wrap;
+
+                case TextureAddressMode.Border:
+                    return SharpDX.Direct3D11.TextureAddressMode.Border;
+
+                default:
+                    throw new ArgumentException("Invalid texture address mode!");
+            }
+        }
+
+        partial void PlatformDispose()
+        {
+            SharpDX.Utilities.Dispose(ref _state);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/States/SamplerState.OpenGL.cs b/MonoGame.Framework/Graphics/States/SamplerState.OpenGL.cs
new file mode 100644
index 00000000000..16d9160737b
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/SamplerState.OpenGL.cs
@@ -0,0 +1,201 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using MonoGame.OpenGL;
+using ExtTextureFilterAnisotropic = MonoGame.OpenGL.TextureParameterName;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+  public partial class SamplerState
+  {
+      private readonly float[] _openGLBorderColor = new float[4];
+
+        internal const TextureParameterName TextureParameterNameTextureMaxAnisotropy = (TextureParameterName)ExtTextureFilterAnisotropic.TextureMaxAnisotropyExt;
+        internal const TextureParameterName TextureParameterNameTextureMaxLevel = TextureParameterName.TextureMaxLevel;
+
+        internal void Activate(GraphicsDevice device, TextureTarget target, bool useMipmaps = false)
+        {
+            if (GraphicsDevice == null)
+            {
+                // We're now bound to a device... no one should
+                // be changing the state of this object now!
+                GraphicsDevice = device;
+            }
+            Debug.Assert(GraphicsDevice == device, "The state was created for a different device!");
+
+            switch (Filter)
+      {
+      case TextureFilter.Point:
+				if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic)
+                {
+                    GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f);
+                    GraphicsExtensions.CheckGLError();
+                }
+        GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.NearestMipmapNearest : TextureMinFilter.Nearest));
+                GraphicsExtensions.CheckGLError();
+        GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest);
+                GraphicsExtensions.CheckGLError();
+        break;
+      case TextureFilter.Linear:
+				if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic)
+                {
+                    GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f);
+                    GraphicsExtensions.CheckGLError();
+                }
+        GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.LinearMipmapLinear : TextureMinFilter.Linear));
+                GraphicsExtensions.CheckGLError();
+        GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
+                GraphicsExtensions.CheckGLError();
+        break;
+      case TextureFilter.Anisotropic:
+				if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic)
+                {
+                    GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, MathHelper.Clamp(this.MaxAnisotropy, 1.0f, GraphicsDevice.GraphicsCapabilities.MaxTextureAnisotropy));
+                    GraphicsExtensions.CheckGLError();
+                }
+        GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.LinearMipmapLinear : TextureMinFilter.Linear));
+                GraphicsExtensions.CheckGLError();
+        GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
+                GraphicsExtensions.CheckGLError();
+        break;
+      case TextureFilter.PointMipLinear:
+				if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic)
+                {
+                    GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f);
+                    GraphicsExtensions.CheckGLError();
+                }
+        GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.NearestMipmapLinear : TextureMinFilter.Nearest));
+                GraphicsExtensions.CheckGLError();
+        GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest);
+                GraphicsExtensions.CheckGLError();
+        break;
+            case TextureFilter.LinearMipPoint:
+				if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic)
+                {
+                    GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f);
+                    GraphicsExtensions.CheckGLError();
+                }
+                GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.LinearMipmapNearest : TextureMinFilter.Linear));
+                GraphicsExtensions.CheckGLError();
+                GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
+                GraphicsExtensions.CheckGLError();
+                break;
+            case TextureFilter.MinLinearMagPointMipLinear:
+				if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic)
+                {
+                    GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f);
+                    GraphicsExtensions.CheckGLError();
+                }
+                GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.LinearMipmapLinear : TextureMinFilter.Linear));
+                GraphicsExtensions.CheckGLError();
+                GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest);
+                GraphicsExtensions.CheckGLError();
+                break;
+            case TextureFilter.MinLinearMagPointMipPoint:
+				if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic)
+                {
+                    GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f);
+                    GraphicsExtensions.CheckGLError();
+                }
+                GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.LinearMipmapNearest: TextureMinFilter.Linear));
+                GraphicsExtensions.CheckGLError();
+                GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Nearest);
+                GraphicsExtensions.CheckGLError();
+                break;
+            case TextureFilter.MinPointMagLinearMipLinear:
+				if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic)
+                {
+                    GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f);
+                    GraphicsExtensions.CheckGLError();
+                }
+                GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.NearestMipmapLinear: TextureMinFilter.Nearest));
+                GraphicsExtensions.CheckGLError();
+                GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
+                GraphicsExtensions.CheckGLError();
+                break;
+            case TextureFilter.MinPointMagLinearMipPoint:
+				if (GraphicsDevice.GraphicsCapabilities.SupportsTextureFilterAnisotropic)
+                {
+                    GL.TexParameter(target, TextureParameterNameTextureMaxAnisotropy, 1.0f);
+                    GraphicsExtensions.CheckGLError();
+                }
+                GL.TexParameter(target, TextureParameterName.TextureMinFilter, (int)(useMipmaps ? TextureMinFilter.NearestMipmapNearest: TextureMinFilter.Nearest));
+                GraphicsExtensions.CheckGLError();
+                GL.TexParameter(target, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
+                GraphicsExtensions.CheckGLError();
+                break;
+      default:
+        throw new NotSupportedException();
+      }
+
+      // Set up texture addressing.
+      GL.TexParameter(target, TextureParameterName.TextureWrapS, (int)GetWrapMode(AddressU));
+            GraphicsExtensions.CheckGLError();
+            GL.TexParameter(target, TextureParameterName.TextureWrapT, (int)GetWrapMode(AddressV));
+            GraphicsExtensions.CheckGLError();
+#if !GLES
+            // Border color is not supported by glTexParameter in OpenGL ES 2.0
+            _openGLBorderColor[0] = BorderColor.R / 255.0f;
+            _openGLBorderColor[1] = BorderColor.G / 255.0f;
+            _openGLBorderColor[2] = BorderColor.B / 255.0f;
+            _openGLBorderColor[3] = BorderColor.A / 255.0f;
+            GL.TexParameter(target, TextureParameterName.TextureBorderColor, _openGLBorderColor);
+            GraphicsExtensions.CheckGLError();
+            // LOD bias is not supported by glTexParameter in OpenGL ES 2.0
+            GL.TexParameter(target, TextureParameterName.TextureLodBias, MipMapLevelOfDetailBias);
+            GraphicsExtensions.CheckGLError();
+            // Comparison samplers are not supported in OpenGL ES 2.0 (without an extension, anyway)
+            switch (FilterMode)
+            {
+                case TextureFilterMode.Comparison:
+                    GL.TexParameter(target, TextureParameterName.TextureCompareMode, (int) TextureCompareMode.CompareRefToTexture);
+                    GraphicsExtensions.CheckGLError();
+                    GL.TexParameter(target, TextureParameterName.TextureCompareFunc, (int) ComparisonFunction.GetDepthFunction());
+                    GraphicsExtensions.CheckGLError();
+                    break;
+                case TextureFilterMode.Default:
+                    GL.TexParameter(target, TextureParameterName.TextureCompareMode, (int) TextureCompareMode.None);
+                    GraphicsExtensions.CheckGLError();
+                    break;
+                default:
+                    throw new InvalidOperationException("Invalid filter mode!");
+            }
+#endif
+            if (GraphicsDevice.GraphicsCapabilities.SupportsTextureMaxLevel)
+            {
+                if (this.MaxMipLevel > 0)
+                {
+                    GL.TexParameter(TextureTarget.Texture2D, TextureParameterNameTextureMaxLevel, this.MaxMipLevel);
+                }
+                else
+                {
+                    GL.TexParameter(TextureTarget.Texture2D, TextureParameterNameTextureMaxLevel, 1000);
+                }
+                GraphicsExtensions.CheckGLError();
+            }
+        }
+
+    private int GetWrapMode(TextureAddressMode textureAddressMode)
+    {
+      switch(textureAddressMode)
+      {
+      case TextureAddressMode.Clamp:
+        return (int)TextureWrapMode.ClampToEdge;
+      case TextureAddressMode.Wrap:
+        return (int)TextureWrapMode.Repeat;
+      case TextureAddressMode.Mirror:
+        return (int)TextureWrapMode.MirroredRepeat;
+#if !GLES
+      case TextureAddressMode.Border:
+        return (int)TextureWrapMode.ClampToBorder;
+#endif
+      default:
+        throw new ArgumentException("No support for " + textureAddressMode);
+      }
+    }
+  }
+}
+
diff --git a/MonoGame.Framework/Graphics/States/SamplerState.Web.cs b/MonoGame.Framework/Graphics/States/SamplerState.Web.cs
new file mode 100644
index 00000000000..d5e083c96f0
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/SamplerState.Web.cs
@@ -0,0 +1,11 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class SamplerState
+    {
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/States/SamplerState.cs b/MonoGame.Framework/Graphics/States/SamplerState.cs
new file mode 100644
index 00000000000..3a9ae80c1d0
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/SamplerState.cs
@@ -0,0 +1,217 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class SamplerState : GraphicsResource
+    {
+        static SamplerState()
+        {
+            AnisotropicClamp = new SamplerState("SamplerState.AnisotropicClamp", TextureFilter.Anisotropic, TextureAddressMode.Clamp);
+            AnisotropicWrap = new SamplerState("SamplerState.AnisotropicWrap", TextureFilter.Anisotropic, TextureAddressMode.Wrap);
+            LinearClamp = new SamplerState("SamplerState.LinearClamp", TextureFilter.Linear, TextureAddressMode.Clamp);
+            LinearWrap = new SamplerState("SamplerState.LinearWrap", TextureFilter.Linear, TextureAddressMode.Wrap);
+            PointClamp = new SamplerState("SamplerState.PointClamp", TextureFilter.Point, TextureAddressMode.Clamp);
+            PointWrap = new SamplerState("SamplerState.PointWrap", TextureFilter.Point, TextureAddressMode.Wrap);
+        }
+
+        public static readonly SamplerState AnisotropicClamp;
+        public static readonly SamplerState AnisotropicWrap;
+        public static readonly SamplerState LinearClamp;
+        public static readonly SamplerState LinearWrap;
+        public static readonly SamplerState PointClamp;
+        public static readonly SamplerState PointWrap;
+
+        private readonly bool _defaultStateObject;
+
+        private TextureAddressMode _addressU;
+        private TextureAddressMode _addressV;
+        private TextureAddressMode _addressW;
+        private Color _borderColor;
+        private TextureFilter _filter;
+        private int _maxAnisotropy;
+        private int _maxMipLevel;
+        private float _mipMapLevelOfDetailBias;
+        private TextureFilterMode _filterMode;
+        private CompareFunction _comparisonFunction;
+
+        public TextureAddressMode AddressU
+        {
+            get { return _addressU; }
+            set
+            {
+                ThrowIfBound();
+                _addressU = value;
+            }
+        }
+
+        public TextureAddressMode AddressV
+        {
+            get { return _addressV; }
+            set
+            {
+                ThrowIfBound();
+                _addressV = value;
+            }
+        }
+
+        public TextureAddressMode AddressW
+        {
+            get { return _addressW; }
+            set
+            {
+                ThrowIfBound();
+                _addressW = value;
+            }
+        }
+
+        public Color BorderColor
+        {
+            get { return _borderColor; }
+            set
+            {
+                ThrowIfBound();
+                _borderColor = value;
+            }
+        }
+
+        public TextureFilter Filter
+        {
+            get { return _filter; }
+            set
+            {
+                ThrowIfBound();
+                _filter = value;
+            }
+        }
+
+        public int MaxAnisotropy
+        {
+            get { return _maxAnisotropy; }
+            set
+            {
+                ThrowIfBound();
+                _maxAnisotropy = value;
+            }
+        }
+
+        public int MaxMipLevel
+        {
+            get { return _maxMipLevel; }
+            set
+            {
+                ThrowIfBound();
+                _maxMipLevel = value;
+            }
+        }
+
+        public float MipMapLevelOfDetailBias
+        {
+            get { return _mipMapLevelOfDetailBias; }
+            set
+            {
+                ThrowIfBound();
+                _mipMapLevelOfDetailBias = value;
+            }
+        }
+
+        /// <summary>
+        /// When using comparison sampling, also set <see cref="FilterMode"/> to <see cref="TextureFilterMode.Comparison"/>.
+        /// </summary>
+        public CompareFunction ComparisonFunction
+        {
+            get { return _comparisonFunction; }
+            set
+            {
+                ThrowIfBound();
+                _comparisonFunction = value;
+            }
+        }
+
+        public TextureFilterMode FilterMode
+        {
+            get { return _filterMode; }
+            set
+            {
+                ThrowIfBound();
+                _filterMode = value;
+            }
+        }
+
+        internal void BindToGraphicsDevice(GraphicsDevice device)
+        {
+            if (_defaultStateObject)
+                throw new InvalidOperationException("You cannot bind a default state object.");
+            if (GraphicsDevice != null && GraphicsDevice != device)
+                throw new InvalidOperationException("This sampler state is already bound to a different graphics device.");
+            GraphicsDevice = device;
+        }
+
+        internal void ThrowIfBound()
+        {
+            if (_defaultStateObject)
+                throw new InvalidOperationException("You cannot modify a default sampler state object.");
+            if (GraphicsDevice != null)
+                throw new InvalidOperationException("You cannot modify the sampler state after it has been bound to the graphics device!");
+        }
+
+        public SamplerState()
+        {
+            Filter = TextureFilter.Linear;
+            AddressU = TextureAddressMode.Wrap;
+            AddressV = TextureAddressMode.Wrap;
+            AddressW = TextureAddressMode.Wrap;
+            BorderColor = Color.White;
+            MaxAnisotropy = 4;
+            MaxMipLevel = 0;
+            MipMapLevelOfDetailBias = 0.0f;
+            ComparisonFunction = CompareFunction.Never;
+            FilterMode = TextureFilterMode.Default;
+        }
+
+        private SamplerState(string name, TextureFilter filter, TextureAddressMode addressMode)
+            : this()
+        {
+            Name = name;
+            _filter = filter;
+            _addressU = addressMode;
+            _addressV = addressMode;
+            _addressW = addressMode;
+            _defaultStateObject = true;
+        }
+
+        private SamplerState(SamplerState cloneSource)
+        {
+            Name = cloneSource.Name;
+            _filter = cloneSource._filter;
+            _addressU = cloneSource._addressU;
+            _addressV = cloneSource._addressV;
+            _addressW = cloneSource._addressW;
+            _borderColor = cloneSource._borderColor;
+            _maxAnisotropy = cloneSource._maxAnisotropy;
+            _maxMipLevel = cloneSource._maxMipLevel;
+            _mipMapLevelOfDetailBias = cloneSource._mipMapLevelOfDetailBias;
+            _comparisonFunction = cloneSource._comparisonFunction;
+            _filterMode = cloneSource._filterMode;
+        }
+
+        internal SamplerState Clone()
+        {
+            return new SamplerState(this);
+        }
+
+        partial void PlatformDispose();
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                PlatformDispose();
+            }
+            base.Dispose(disposing);
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/States/StencilOperation.cs b/MonoGame.Framework/Graphics/States/StencilOperation.cs
new file mode 100644
index 00000000000..47a758750f7
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/StencilOperation.cs
@@ -0,0 +1,45 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines stencil buffer operations.
+    /// </summary>
+    public enum StencilOperation
+    {
+        /// <summary>
+        /// Does not update the stencil buffer entry.
+        /// </summary>
+        Keep,
+        /// <summary>
+        /// Sets the stencil buffer entry to 0.
+        /// </summary>
+        Zero,
+        /// <summary>
+        /// Replaces the stencil buffer entry with a reference value.
+        /// </summary>
+        Replace,
+        /// <summary>
+        /// Increments the stencil buffer entry, wrapping to 0 if the new value exceeds the maximum value.
+        /// </summary>
+        Increment,
+        /// <summary>
+        /// Decrements the stencil buffer entry, wrapping to the maximum value if the new value is less than 0.
+        /// </summary>
+        Decrement,
+        /// <summary>
+        /// Increments the stencil buffer entry, clamping to the maximum value.
+        /// </summary>
+        IncrementSaturation,
+        /// <summary>
+        /// Decrements the stencil buffer entry, clamping to 0.
+        /// </summary>
+        DecrementSaturation,
+        /// <summary>
+        /// Inverts the bits in the stencil buffer entry.
+        /// </summary>
+        Invert
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/States/TargetBlendState.cs b/MonoGame.Framework/Graphics/States/TargetBlendState.cs
new file mode 100644
index 00000000000..5072d2f1f7c
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/TargetBlendState.cs
@@ -0,0 +1,220 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public class TargetBlendState
+	{
+	    private readonly BlendState _parent;
+	    private BlendFunction _alphaBlendFunction;
+	    private Blend _alphaDestinationBlend;
+	    private Blend _alphaSourceBlend;
+	    private BlendFunction _colorBlendFunction;
+	    private Blend _colorDestinationBlend;
+	    private Blend _colorSourceBlend;
+	    private ColorWriteChannels _colorWriteChannels;
+
+	    internal TargetBlendState(BlendState parent)
+        {
+	        _parent = parent;
+	        AlphaBlendFunction = BlendFunction.Add;
+            AlphaDestinationBlend = Blend.Zero;
+            AlphaSourceBlend = Blend.One;
+            ColorBlendFunction = BlendFunction.Add;
+            ColorDestinationBlend = Blend.Zero;
+            ColorSourceBlend = Blend.One;
+            ColorWriteChannels = ColorWriteChannels.All;
+        }
+
+	    internal TargetBlendState Clone(BlendState parent)
+	    {
+	        return new TargetBlendState(parent)
+	        {
+	            AlphaBlendFunction = AlphaBlendFunction,
+                AlphaDestinationBlend = AlphaDestinationBlend,
+                AlphaSourceBlend = AlphaSourceBlend,
+                ColorBlendFunction = ColorBlendFunction,
+                ColorDestinationBlend = ColorDestinationBlend,
+                ColorSourceBlend = ColorSourceBlend,
+                ColorWriteChannels = ColorWriteChannels
+	        };
+	    }
+
+	    public BlendFunction AlphaBlendFunction
+	    {
+	        get { return _alphaBlendFunction; }
+	        set
+	        {
+	            _parent.ThrowIfBound();
+	            _alphaBlendFunction = value;
+	        }
+	    }
+
+	    public Blend AlphaDestinationBlend
+	    {
+	        get { return _alphaDestinationBlend; }
+	        set
+	        {
+                _parent.ThrowIfBound();
+	            _alphaDestinationBlend = value;
+	        }
+	    }
+
+	    public Blend AlphaSourceBlend
+	    {
+	        get { return _alphaSourceBlend; }
+	        set
+	        {
+                _parent.ThrowIfBound();
+	            _alphaSourceBlend = value;
+	        }
+	    }
+
+	    public BlendFunction ColorBlendFunction
+	    {
+	        get { return _colorBlendFunction; }
+	        set
+	        {
+                _parent.ThrowIfBound();
+	            _colorBlendFunction = value;
+	        }
+	    }
+
+	    public Blend ColorDestinationBlend
+	    {
+	        get { return _colorDestinationBlend; }
+	        set
+	        {
+                _parent.ThrowIfBound();
+	            _colorDestinationBlend = value;
+	        }
+	    }
+
+	    public Blend ColorSourceBlend
+	    {
+	        get { return _colorSourceBlend; }
+	        set
+	        {
+                _parent.ThrowIfBound();
+	            _colorSourceBlend = value;
+	        }
+	    }
+
+	    public ColorWriteChannels ColorWriteChannels
+	    {
+	        get { return _colorWriteChannels; }
+	        set
+	        {
+                _parent.ThrowIfBound();
+	            _colorWriteChannels = value;
+	        }
+	    }
+
+#if DIRECTX
+
+        internal void GetState(ref SharpDX.Direct3D11.RenderTargetBlendDescription desc)
+        {
+            // We're blending if we're not in the opaque state.
+            desc.IsBlendEnabled =   !(  ColorSourceBlend == Blend.One &&
+                                        ColorDestinationBlend == Blend.Zero &&
+                                        AlphaSourceBlend == Blend.One &&
+                                        AlphaDestinationBlend == Blend.Zero);
+
+            desc.BlendOperation = GetBlendOperation(ColorBlendFunction);
+            desc.SourceBlend = GetBlendOption(ColorSourceBlend, false);
+            desc.DestinationBlend = GetBlendOption(ColorDestinationBlend, false);
+
+            desc.AlphaBlendOperation = GetBlendOperation(AlphaBlendFunction);
+            desc.SourceAlphaBlend = GetBlendOption(AlphaSourceBlend, true);
+            desc.DestinationAlphaBlend = GetBlendOption(AlphaDestinationBlend, true);
+
+            desc.RenderTargetWriteMask = GetColorWriteMask(ColorWriteChannels);
+        }
+
+        static private SharpDX.Direct3D11.BlendOperation GetBlendOperation(BlendFunction blend)
+        {
+            switch (blend)
+            {
+                case BlendFunction.Add:
+                    return SharpDX.Direct3D11.BlendOperation.Add;
+
+                case BlendFunction.Max:
+                    return SharpDX.Direct3D11.BlendOperation.Maximum;
+
+                case BlendFunction.Min:
+                    return SharpDX.Direct3D11.BlendOperation.Minimum;
+
+                case BlendFunction.ReverseSubtract:
+                    return SharpDX.Direct3D11.BlendOperation.ReverseSubtract;
+
+                case BlendFunction.Subtract:
+                    return SharpDX.Direct3D11.BlendOperation.Subtract;
+
+                default:
+                    throw new ArgumentException("Invalid blend function!");
+            }
+        }
+
+        static private SharpDX.Direct3D11.BlendOption GetBlendOption(Blend blend, bool alpha)
+        {
+            switch (blend)
+            {
+                case Blend.BlendFactor:
+                    return SharpDX.Direct3D11.BlendOption.BlendFactor;
+
+                case Blend.DestinationAlpha:
+                    return SharpDX.Direct3D11.BlendOption.DestinationAlpha;
+
+                case Blend.DestinationColor:
+                    return alpha ? SharpDX.Direct3D11.BlendOption.DestinationAlpha : SharpDX.Direct3D11.BlendOption.DestinationColor;
+
+                case Blend.InverseBlendFactor:
+                    return SharpDX.Direct3D11.BlendOption.InverseBlendFactor;
+
+                case Blend.InverseDestinationAlpha:
+                    return SharpDX.Direct3D11.BlendOption.InverseDestinationAlpha;
+
+                case Blend.InverseDestinationColor:
+                    return alpha ? SharpDX.Direct3D11.BlendOption.InverseDestinationAlpha : SharpDX.Direct3D11.BlendOption.InverseDestinationColor;
+
+                case Blend.InverseSourceAlpha:
+                    return SharpDX.Direct3D11.BlendOption.InverseSourceAlpha;
+
+                case Blend.InverseSourceColor:
+                    return alpha ? SharpDX.Direct3D11.BlendOption.InverseSourceAlpha : SharpDX.Direct3D11.BlendOption.InverseSourceColor;
+
+                case Blend.One:
+                    return SharpDX.Direct3D11.BlendOption.One;
+
+                case Blend.SourceAlpha:
+                    return SharpDX.Direct3D11.BlendOption.SourceAlpha;
+
+                case Blend.SourceAlphaSaturation:
+                    return SharpDX.Direct3D11.BlendOption.SourceAlphaSaturate;
+
+                case Blend.SourceColor:
+                    return alpha ? SharpDX.Direct3D11.BlendOption.SourceAlpha : SharpDX.Direct3D11.BlendOption.SourceColor;
+
+                case Blend.Zero:
+                    return SharpDX.Direct3D11.BlendOption.Zero;
+
+                default:
+                    throw new ArgumentException("Invalid blend!");
+            }
+        }
+
+        static private SharpDX.Direct3D11.ColorWriteMaskFlags GetColorWriteMask(ColorWriteChannels mask)
+        {
+            return  ((mask & ColorWriteChannels.Red) != 0 ? SharpDX.Direct3D11.ColorWriteMaskFlags.Red : 0) |
+                    ((mask & ColorWriteChannels.Green) != 0 ? SharpDX.Direct3D11.ColorWriteMaskFlags.Green : 0) |
+                    ((mask & ColorWriteChannels.Blue) != 0 ? SharpDX.Direct3D11.ColorWriteMaskFlags.Blue : 0) |
+                    ((mask & ColorWriteChannels.Alpha) != 0 ? SharpDX.Direct3D11.ColorWriteMaskFlags.Alpha : 0);
+        }
+#endif
+
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/States/TextureAddressMode.cs b/MonoGame.Framework/Graphics/States/TextureAddressMode.cs
new file mode 100644
index 00000000000..ebb109f6cc2
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/TextureAddressMode.cs
@@ -0,0 +1,29 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines modes for addressing texels using texture coordinates that are outside of the range of 0.0 to 1.0.
+    /// </summary>
+	public enum TextureAddressMode
+	{
+        /// <summary>
+        /// Texels outside range will form the tile at every integer junction.
+        /// </summary>
+		Wrap,
+        /// <summary>
+        /// Texels outside range will be set to color of 0.0 or 1.0 texel.
+        /// </summary>
+		Clamp,
+        /// <summary>
+        /// Same as <see cref="TextureAddressMode.Wrap"/> but tiles will also flipped at every integer junction.
+        /// </summary>
+        Mirror,
+        /// <summary>
+        /// Texels outside range will be set to the border color.
+        /// </summary>
+        Border
+	}
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/States/TextureFilter.cs b/MonoGame.Framework/Graphics/States/TextureFilter.cs
new file mode 100644
index 00000000000..f3e8750ca31
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/TextureFilter.cs
@@ -0,0 +1,49 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines filtering types for texture sampler.
+    /// </summary>
+	public enum TextureFilter
+	{
+        /// <summary>
+        /// Use linear filtering.
+        /// </summary>
+		Linear,
+        /// <summary>
+        /// Use point filtering.
+        /// </summary>
+		Point,
+        /// <summary>
+        /// Use anisotropic filtering.
+        /// </summary>
+		Anisotropic,	
+        /// <summary>
+        /// Use linear filtering to shrink or expand, and point filtering between mipmap levels (mip).
+        /// </summary>
+		LinearMipPoint,
+        /// <summary>
+        /// Use point filtering to shrink (minify) or expand (magnify), and linear filtering between mipmap levels.
+        /// </summary>
+		PointMipLinear,
+        /// <summary>
+        /// Use linear filtering to shrink, point filtering to expand, and linear filtering between mipmap levels.
+        /// </summary>
+		MinLinearMagPointMipLinear,
+        /// <summary>
+        /// Use linear filtering to shrink, point filtering to expand, and point filtering between mipmap levels.
+        /// </summary>
+		MinLinearMagPointMipPoint,
+        /// <summary>
+        /// Use point filtering to shrink, linear filtering to expand, and linear filtering between mipmap levels.
+        /// </summary>
+		MinPointMagLinearMipLinear,
+        /// <summary>
+        /// Use point filtering to shrink, linear filtering to expand, and point filtering between mipmap levels.
+        /// </summary>
+		MinPointMagLinearMipPoint
+	}
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/States/TextureFilterMode.cs b/MonoGame.Framework/Graphics/States/TextureFilterMode.cs
new file mode 100644
index 00000000000..5f945f2119a
--- /dev/null
+++ b/MonoGame.Framework/Graphics/States/TextureFilterMode.cs
@@ -0,0 +1,15 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Filtering modes for texture samplers.
+    /// </summary>
+    public enum TextureFilterMode
+    {
+        Default,
+        Comparison
+    }
+}
diff --git a/MonoGame.Framework/Graphics/SurfaceFormat.cs b/MonoGame.Framework/Graphics/SurfaceFormat.cs
new file mode 100644
index 00000000000..5fd7e7c8e22
--- /dev/null
+++ b/MonoGame.Framework/Graphics/SurfaceFormat.cs
@@ -0,0 +1,165 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines types of surface formats.
+    /// </summary>
+    public enum SurfaceFormat
+    {
+        /// <summary>
+        /// Unsigned 32-bit ARGB pixel format for store 8 bits per channel. 
+        /// </summary>
+        Color,
+        /// <summary>
+        /// Unsigned 16-bit BGR pixel format for store 5 bits for blue, 6 bits for green, and 5 bits for red.   
+        /// </summary>
+        Bgr565,
+        /// <summary>
+        /// Unsigned 16-bit BGRA pixel format where 5 bits reserved for each color and last bit is reserved for alpha.
+        /// </summary>
+        Bgra5551,
+        /// <summary>
+        /// Unsigned 16-bit BGRA pixel format for store 4 bits per channel.
+        /// </summary>
+        Bgra4444,
+        /// <summary>
+        /// DXT1. Texture format with compression. Surface dimensions must be a multiple 4.
+        /// </summary>
+        Dxt1,
+        /// <summary>
+        /// DXT3. Texture format with compression. Surface dimensions must be a multiple 4.
+        /// </summary>
+        Dxt3, 
+        /// <summary>
+        /// DXT5. Texture format with compression. Surface dimensions must be a multiple 4.
+        /// </summary>
+        Dxt5 = 6,
+        /// <summary>
+        /// Signed 16-bit bump-map format for store 8 bits for <c>u</c> and <c>v</c> data.
+        /// </summary>
+        NormalizedByte2,
+        /// <summary>
+        /// Signed 32-bit bump-map format for store 8 bits per channel.
+        /// </summary>
+        NormalizedByte4,
+        /// <summary>
+        /// Unsigned 32-bit RGBA pixel format for store 10 bits for each color and 2 bits for alpha.
+        /// </summary>
+        Rgba1010102,
+        /// <summary>
+        /// Unsigned 32-bit RG pixel format using 16 bits per channel.
+        /// </summary>
+        Rg32,
+        /// <summary>
+        /// Unsigned 64-bit RGBA pixel format using 16 bits per channel.
+        /// </summary>
+        Rgba64,
+        /// <summary>
+        /// Unsigned A 8-bit format for store 8 bits to alpha channel.
+        /// </summary>
+        Alpha8,
+        /// <summary>
+        /// IEEE 32-bit R float format for store 32 bits to red channel.
+        /// </summary>
+        Single,
+        /// <summary>
+        /// IEEE 64-bit RG float format for store 32 bits per channel.
+        /// </summary>
+        Vector2,
+        /// <summary>
+        /// IEEE 128-bit RGBA float format for store 32 bits per channel.
+        /// </summary>
+        Vector4,
+        /// <summary>
+        /// Float 16-bit R format for store 16 bits to red channel.   
+        /// </summary>
+        HalfSingle,
+        /// <summary>
+        /// Float 32-bit RG format for store 16 bits per channel. 
+        /// </summary>
+        HalfVector2,
+        /// <summary>
+        /// Float 64-bit ARGB format for store 16 bits per channel. 
+        /// </summary>
+        HalfVector4,
+        /// <summary>
+        /// Float pixel format for high dynamic range data.
+        /// </summary>
+        HdrBlendable,
+
+        #region Extensions
+
+        /// <summary>
+        /// For compatibility with WPF D3DImage.
+        /// </summary>
+        Bgr32 = 20,     // B8G8R8X8
+        /// <summary>
+        /// For compatibility with WPF D3DImage.
+        /// </summary>
+        Bgra32 = 21,    // B8G8R8A8    
+
+        /// <summary>
+        /// Unsigned 32-bit RGBA sRGB pixel format that supports 8 bits per channel.
+        /// </summary>
+        ColorSRgb = 30,
+        /// <summary>
+        /// Unsigned 32-bit sRGB pixel format that supports 8 bits per channel. 8 bits are unused.
+        /// </summary>
+        Bgr32SRgb = 31,
+        /// <summary>
+        /// Unsigned 32-bit sRGB pixel format that supports 8 bits per channel.
+        /// </summary>
+        Bgra32SRgb = 32,
+        /// <summary>
+        /// DXT1. sRGB texture format with compression. Surface dimensions must be a multiple of 4.
+        /// </summary>
+        Dxt1SRgb = 33,
+        /// <summary>
+        /// DXT3. sRGB texture format with compression. Surface dimensions must be a multiple of 4.
+        /// </summary>
+        Dxt3SRgb = 34,
+        /// <summary>
+        /// DXT5. sRGB texture format with compression. Surface dimensions must be a multiple of 4.
+        /// </summary>
+        Dxt5SRgb = 35,
+
+		/// <summary>
+        /// PowerVR texture compression format (iOS and Android).
+		/// </summary>
+		RgbPvrtc2Bpp = 50,
+        /// <summary>
+        /// PowerVR texture compression format (iOS and Android).
+        /// </summary>
+		RgbPvrtc4Bpp = 51,
+        /// <summary>
+        /// PowerVR texture compression format (iOS and Android).
+        /// </summary>
+		RgbaPvrtc2Bpp = 52,
+        /// <summary>
+        /// PowerVR texture compression format (iOS and Android).
+        /// </summary>
+		RgbaPvrtc4Bpp = 53,
+		/// <summary>
+        /// Ericcson Texture Compression (Android)
+		/// </summary>
+		RgbEtc1 = 60,
+        /// <summary>
+        /// DXT1 version where 1-bit alpha is used.
+        /// </summary>
+        Dxt1a = 70,
+        /// <summary>
+        /// ATC/ATITC compression (Android)
+        /// </summary>
+        RgbaAtcExplicitAlpha =  80,
+        /// <summary>
+        /// ATC/ATITC compression (Android)
+        /// </summary>
+        RgbaAtcInterpolatedAlpha = 81,
+
+        #endregion
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/SwapChainRenderTarget.cs b/MonoGame.Framework/Graphics/SwapChainRenderTarget.cs
new file mode 100644
index 00000000000..15afd0e1ad3
--- /dev/null
+++ b/MonoGame.Framework/Graphics/SwapChainRenderTarget.cs
@@ -0,0 +1,180 @@
+using System;
+
+#if WINDOWS && DIRECTX
+using SharpDX.DXGI;
+using SharpDX.Direct3D11;
+#endif
+
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+#if WINDOWS && DIRECTX
+
+    /// <summary>
+    /// A swap chain used for rendering to a secondary GameWindow.
+    /// </summary>
+    /// <remarks>
+    /// This is an extension and not part of stock XNA.
+    /// It is currently implemented for Windows and DirectX only.
+    /// </remarks>
+    public class SwapChainRenderTarget : RenderTarget2D
+    {
+        private SwapChain _swapChain;
+
+        public PresentInterval PresentInterval;
+
+        public SwapChainRenderTarget(   GraphicsDevice graphicsDevice,
+                                        IntPtr windowHandle,
+                                        int width,
+                                        int height)
+            : this( 
+                graphicsDevice, 
+                windowHandle, 
+                width, 
+                height, 
+                false, 
+                SurfaceFormat.Color,
+                DepthFormat.Depth24,
+                0, 
+                RenderTargetUsage.DiscardContents,
+                PresentInterval.Default)
+        {
+        }
+
+        public SwapChainRenderTarget(   GraphicsDevice graphicsDevice,
+                                        IntPtr windowHandle,                                     
+                                        int width,
+                                        int height,
+                                        bool mipMap,
+                                        SurfaceFormat surfaceFormat,
+                                        DepthFormat depthFormat,                                        
+                                        int preferredMultiSampleCount,
+                                        RenderTargetUsage usage,
+                                        PresentInterval presentInterval)
+            : base(
+                graphicsDevice,
+                width,
+                height,
+                mipMap,
+                surfaceFormat,
+                depthFormat,
+                preferredMultiSampleCount,
+                usage,
+                SurfaceType.SwapChainRenderTarget)
+        {
+            var dxgiFormat = surfaceFormat == SurfaceFormat.Color
+                             ? SharpDX.DXGI.Format.B8G8R8A8_UNorm
+                             : SharpDXHelper.ToFormat(surfaceFormat);
+
+            var multisampleDesc = new SampleDescription(1, 0);
+            if (preferredMultiSampleCount > 1)
+            {
+                multisampleDesc.Count = preferredMultiSampleCount;
+                multisampleDesc.Quality = (int)StandardMultisampleQualityLevels.StandardMultisamplePattern;
+            }
+
+            var desc = new SwapChainDescription()
+            {
+                ModeDescription =
+                {
+                    Format = dxgiFormat,
+                    Scaling = DisplayModeScaling.Stretched,
+                    Width = width,
+                    Height = height,
+                },
+
+                OutputHandle = windowHandle,
+                SampleDescription = multisampleDesc,
+                Usage = Usage.RenderTargetOutput,
+                BufferCount = 2,
+                SwapEffect = SharpDXHelper.ToSwapEffect(presentInterval),
+                IsWindowed = true,
+            };
+
+            PresentInterval = presentInterval;
+
+            // Once the desired swap chain description is configured, it must 
+            // be created on the same adapter as our D3D Device
+            var d3dDevice = graphicsDevice._d3dDevice;
+
+            // First, retrieve the underlying DXGI Device from the D3D Device.
+            // Creates the swap chain 
+            using (var dxgiDevice = d3dDevice.QueryInterface<SharpDX.DXGI.Device1>())
+            using (var dxgiAdapter = dxgiDevice.Adapter)
+            using (var dxgiFactory = dxgiAdapter.GetParent<Factory1>())
+            {
+                _swapChain = new SwapChain(dxgiFactory, dxgiDevice, desc);
+            }
+
+            // Obtain the backbuffer for this window which will be the final 3D rendertarget.
+            var backBuffer = SharpDX.Direct3D11.Resource.FromSwapChain<SharpDX.Direct3D11.Texture2D>(_swapChain, 0);
+
+            // Create a view interface on the rendertarget to use on bind.
+            _renderTargetViews = new[] { new RenderTargetView(d3dDevice, backBuffer) };
+
+            // Get the rendertarget dimensions for later.
+            var backBufferDesc = backBuffer.Description;
+            var targetSize = new Point(backBufferDesc.Width, backBufferDesc.Height);
+
+            _texture = backBuffer;
+
+            // Create the depth buffer if we need it.
+            if (depthFormat != DepthFormat.None)
+            {
+                dxgiFormat = SharpDXHelper.ToFormat(depthFormat);
+
+                // Allocate a 2-D surface as the depth/stencil buffer.
+                using (
+                    var depthBuffer = new SharpDX.Direct3D11.Texture2D(d3dDevice,
+                                                                       new Texture2DDescription()
+                                                                           {
+                                                                               Format = dxgiFormat,
+                                                                               ArraySize = 1,
+                                                                               MipLevels = 1,
+                                                                               Width = targetSize.X,
+                                                                               Height = targetSize.Y,
+                                                                               SampleDescription = multisampleDesc,
+                                                                               Usage = ResourceUsage.Default,
+                                                                               BindFlags = BindFlags.DepthStencil,
+                                                                           }))
+
+                    // Create a DepthStencil view on this surface to use on bind.
+                    _depthStencilView = new DepthStencilView(d3dDevice, depthBuffer);
+            }
+        }
+
+
+        // TODO: We need to expose the other Present() overloads
+        // for passing source/dest rectangles.
+
+        /// <summary>
+        /// Displays the contents of the active back buffer to the screen.
+        /// </summary>
+        public void Present()
+        {
+            lock (GraphicsDevice._d3dContext)
+            {
+                try
+                {
+                    _swapChain.Present(PresentInterval.GetSyncInterval(), PresentFlags.None);
+                }
+                catch (SharpDX.SharpDXException)
+                {
+                }
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                SharpDX.Utilities.Dispose(ref _swapChain);
+            }
+
+            base.Dispose(disposing);
+        }
+
+    }
+
+#endif // WINDOWS && DIRECTX
+}
diff --git a/MonoGame.Framework/Graphics/Texture.DirectX.cs b/MonoGame.Framework/Graphics/Texture.DirectX.cs
new file mode 100644
index 00000000000..17e83152df1
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Texture.DirectX.cs
@@ -0,0 +1,70 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public abstract partial class Texture
+    {
+        internal SharpDX.Direct3D11.Resource _texture;
+
+        private SharpDX.Direct3D11.ShaderResourceView _resourceView;
+
+        /// <summary>
+        /// Gets the handle to a shared resource.
+        /// </summary>
+        /// <returns>
+        /// The handle of the shared resource, or <see cref="IntPtr.Zero"/> if the texture was not
+        /// created as a shared resource.
+        /// </returns>
+        public IntPtr GetSharedHandle()
+        {
+            using (var resource = _texture.QueryInterface<SharpDX.DXGI.Resource>())
+                return resource.SharedHandle;
+        }
+
+        internal abstract SharpDX.Direct3D11.Resource CreateTexture();
+
+        internal SharpDX.Direct3D11.Resource GetTexture()
+        {
+            if (_texture == null)
+                _texture = CreateTexture();
+
+            return _texture;
+        }
+
+        internal SharpDX.Direct3D11.ShaderResourceView GetShaderResourceView()
+        {
+            if (_resourceView == null)
+                _resourceView = CreateShaderResourceView();
+
+            return _resourceView;
+        }
+
+        protected virtual SharpDX.Direct3D11.ShaderResourceView
+            CreateShaderResourceView()
+        {
+            return new SharpDX.Direct3D11.ShaderResourceView(GraphicsDevice._d3dDevice, GetTexture());
+        }
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            SharpDX.Utilities.Dispose(ref _resourceView);
+            SharpDX.Utilities.Dispose(ref _texture);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                SharpDX.Utilities.Dispose(ref _resourceView);
+                SharpDX.Utilities.Dispose(ref _texture);
+            }
+
+            base.Dispose(disposing);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/Texture.OpenGL.cs b/MonoGame.Framework/Graphics/Texture.OpenGL.cs
new file mode 100644
index 00000000000..f94887de4f2
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Texture.OpenGL.cs
@@ -0,0 +1,46 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public abstract partial class Texture
+    {
+        internal int glTexture = -1;
+        internal TextureTarget glTarget;
+        internal TextureUnit glTextureUnit = TextureUnit.Texture0;
+        internal PixelInternalFormat glInternalFormat;
+        internal PixelFormat glFormat;
+        internal PixelType glType;
+        internal SamplerState glLastSamplerState;
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            DeleteGLTexture();
+            glLastSamplerState = null;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                DeleteGLTexture();
+                glLastSamplerState = null;
+            }
+
+            base.Dispose(disposing);
+        }
+
+        private void DeleteGLTexture()
+        {
+            if (glTexture > 0)
+            {
+                GraphicsDevice.DisposeTexture(glTexture);
+            }
+            glTexture = -1;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/Texture.Web.cs b/MonoGame.Framework/Graphics/Texture.Web.cs
new file mode 100644
index 00000000000..a83524b68c3
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Texture.Web.cs
@@ -0,0 +1,33 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public abstract partial class Texture
+    {
+        internal int glTexture = -1;
+        internal SamplerState glLastSamplerState;
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            glTexture = -1;
+            glLastSamplerState = null;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                glTexture = -1;
+                glLastSamplerState = null;
+            }
+
+            base.Dispose(disposing);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/Texture.cs b/MonoGame.Framework/Graphics/Texture.cs
new file mode 100644
index 00000000000..74f585c6d28
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Texture.cs
@@ -0,0 +1,127 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using System.Threading;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public abstract partial class Texture : GraphicsResource
+	{
+		internal SurfaceFormat _format;
+		internal int _levelCount;
+
+        private readonly int _sortingKey = Interlocked.Increment(ref _lastSortingKey);
+        private static int _lastSortingKey;
+
+        /// <summary>
+        /// Gets a unique identifier of this texture for sorting purposes.
+        /// </summary>
+        /// <remarks>
+        /// <para>For example, this value is used by <see cref="SpriteBatch"/> when drawing with <see cref="SpriteSortMode.Texture"/>.</para>
+        /// <para>The value is an implementation detail and may change between application launches or MonoGame versions.
+        /// It is only guaranteed to stay consistent during application lifetime.</para>
+        /// </remarks>
+        internal int SortingKey
+        {
+            get { return _sortingKey; }
+        }
+
+		public SurfaceFormat Format
+		{
+			get { return _format; }
+		}
+		
+		public int LevelCount
+		{
+			get { return _levelCount; }
+		}
+
+        internal static int CalculateMipLevels(int width, int height = 0, int depth = 0)
+        {
+            int levels = 1;
+            int size = Math.Max(Math.Max(width, height), depth);
+            while (size > 1)
+            {
+                size = size / 2;
+                levels++;
+            }
+            return levels;
+        }
+
+        internal static void GetSizeForLevel(int width, int height, int level, out int w, out int h)
+        {
+            w = width;
+            h = height;
+            while (level > 0)
+            {
+                --level;
+                w /= 2;
+                h /= 2;
+            }
+            if (w == 0)
+                w = 1;
+            if (h == 0)
+                h = 1;
+        }
+
+        internal static void GetSizeForLevel(int width, int height, int depth, int level, out int w, out int h, out int d)
+        {
+            w = width;
+            h = height;
+            d = depth;
+            while (level > 0)
+            {
+                --level;
+                w /= 2;
+                h /= 2;
+                d /= 2;
+            }
+            if (w == 0)
+                w = 1;
+            if (h == 0)
+                h = 1;
+            if (d == 0)
+                d = 1;
+        }
+
+        internal int GetPitch(int width)
+        {
+            Debug.Assert(width > 0, "The width is negative!");
+
+            int pitch;
+
+            switch (_format)
+            {
+                case SurfaceFormat.Dxt1:
+                case SurfaceFormat.Dxt1SRgb:
+                case SurfaceFormat.Dxt1a:
+                case SurfaceFormat.RgbPvrtc2Bpp:
+                case SurfaceFormat.RgbaPvrtc2Bpp:
+                case SurfaceFormat.RgbEtc1:
+                case SurfaceFormat.Dxt3:
+                case SurfaceFormat.Dxt3SRgb:
+                case SurfaceFormat.Dxt5:
+                case SurfaceFormat.Dxt5SRgb:
+                case SurfaceFormat.RgbPvrtc4Bpp:
+                case SurfaceFormat.RgbaPvrtc4Bpp:                    
+                    pitch = ((width + 3) / 4) * _format.GetSize();
+                    break;
+
+                default:
+                    pitch = width * _format.GetSize();
+                    break;
+            };
+
+            return pitch;
+        }
+
+        internal protected override void GraphicsDeviceResetting()
+        {
+            PlatformGraphicsDeviceResetting();
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/Texture2D.DirectX.cs b/MonoGame.Framework/Graphics/Texture2D.DirectX.cs
new file mode 100644
index 00000000000..f1f53705605
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Texture2D.DirectX.cs
@@ -0,0 +1,421 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using MonoGame.Utilities;
+using MonoGame.Utilities.Png;
+using SharpDX;
+using SharpDX.Direct3D11;
+using SharpDX.DXGI;
+using SharpDX.WIC;
+using MapFlags = SharpDX.Direct3D11.MapFlags;
+using Resource = SharpDX.Direct3D11.Resource;
+
+#if WINDOWS_UAP
+using Windows.Graphics.Imaging;
+using Windows.Storage.Streams;
+using System.Threading.Tasks;
+#endif
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class Texture2D : Texture
+    {
+        protected bool Shared { get { return _shared; } }
+        protected bool Mipmap { get { return _mipmap; } }
+        protected SampleDescription SampleDescription { get { return _sampleDescription; } }
+
+        private bool _shared;
+        private bool _mipmap;
+        private SampleDescription _sampleDescription;
+
+        private SharpDX.Direct3D11.Texture2D _cachedStagingTexture;
+
+        private void PlatformConstruct(int width, int height, bool mipmap, SurfaceFormat format, SurfaceType type, bool shared)
+        {
+            _shared = shared;
+            _mipmap = mipmap;
+        }
+
+        private void PlatformSetData<T>(int level, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            int w, h;
+            GetSizeForLevel(Width, Height, level, out w, out h);
+
+            // For DXT compressed formats the width and height must be
+            // a multiple of 4 for the complete mip level to be set.
+            if (_format.IsCompressedFormat())
+            {
+                w = (w + 3) & ~3;
+                h = (h + 3) & ~3;
+            }
+
+            var elementSizeInByte = ReflectionHelpers.SizeOf<T>.Get();
+            var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+            // Use try..finally to make sure dataHandle is freed in case of an error
+            try
+            {
+                var startBytes = startIndex * elementSizeInByte;
+                var dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startBytes);
+                var region = new ResourceRegion();
+                region.Top = 0;
+                region.Front = 0;
+                region.Back = 1;
+                region.Bottom = h;
+                region.Left = 0;
+                region.Right = w;
+
+                // TODO: We need to deal with threaded contexts here!
+                var subresourceIndex = CalculateSubresourceIndex(0, level);
+                var d3dContext = GraphicsDevice._d3dContext;
+                lock (d3dContext)
+                    d3dContext.UpdateSubresource(GetTexture(), subresourceIndex, region, dataPtr, GetPitch(w), 0);
+            }
+            finally
+            {
+                dataHandle.Free();
+            }
+        }
+
+        private void PlatformSetData<T>(int level, int arraySlice, Rectangle rect, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            var elementSizeInByte = ReflectionHelpers.SizeOf<T>.Get();
+            var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+            // Use try..finally to make sure dataHandle is freed in case of an error
+            try
+            {
+                var startBytes = startIndex * elementSizeInByte;
+                var dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startBytes);
+                var region = new ResourceRegion();
+                region.Top = rect.Top;
+                region.Front = 0;
+                region.Back = 1;
+                region.Bottom = rect.Bottom;
+                region.Left = rect.Left;
+                region.Right = rect.Right;
+
+
+                // TODO: We need to deal with threaded contexts here!
+                var subresourceIndex = CalculateSubresourceIndex(arraySlice, level);
+                var d3dContext = GraphicsDevice._d3dContext;
+                lock (d3dContext)
+                    d3dContext.UpdateSubresource(GetTexture(), subresourceIndex, region, dataPtr, GetPitch(rect.Width), 0);
+            }
+            finally
+            {
+                dataHandle.Free();
+            }
+        }
+
+        private void PlatformGetData<T>(int level, int arraySlice, Rectangle rect, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            // Create a temp staging resource for copying the data.
+            // 
+            // TODO: We should probably be pooling these staging resources
+            // and not creating a new one each time.
+            //
+            var min = _format.IsCompressedFormat() ? 4 : 1;
+            var levelWidth = Math.Max(width >> level, min);
+            var levelHeight = Math.Max(height >> level, min);
+
+            if (_cachedStagingTexture == null)
+            {
+                var desc = new Texture2DDescription();
+                desc.Width = levelWidth;
+                desc.Height = levelHeight;
+                desc.MipLevels = 1;
+                desc.ArraySize = 1;
+                desc.Format = SharpDXHelper.ToFormat(_format);
+                desc.BindFlags = BindFlags.None;
+                desc.CpuAccessFlags = CpuAccessFlags.Read;
+                desc.SampleDescription = CreateSampleDescription();
+                desc.Usage = ResourceUsage.Staging;
+                desc.OptionFlags = ResourceOptionFlags.None;
+
+                // Save sampling description.
+                _sampleDescription = desc.SampleDescription;
+
+                _cachedStagingTexture = new SharpDX.Direct3D11.Texture2D(GraphicsDevice._d3dDevice, desc);
+            }
+
+            var d3dContext = GraphicsDevice._d3dContext;
+
+            lock (d3dContext)
+            {
+                var subresourceIndex = CalculateSubresourceIndex(arraySlice, level);
+
+                // Copy the data from the GPU to the staging texture.
+                var elementsInRow = rect.Width;
+                var rows = rect.Height;
+                var region = new ResourceRegion(rect.Left, rect.Top, 0, rect.Right, rect.Bottom, 1);
+                d3dContext.CopySubresourceRegion(GetTexture(), subresourceIndex, region, _cachedStagingTexture, 0);
+
+                // Copy the data to the array.
+                DataStream stream = null;
+                try
+                {
+                    var databox = d3dContext.MapSubresource(_cachedStagingTexture, 0, MapMode.Read, MapFlags.None, out stream);
+
+                    var elementSize = _format.GetSize();
+                    if (_format.IsCompressedFormat())
+                    {
+                        // for 4x4 block compression formats an element is one block, so elementsInRow
+                        // and number of rows are 1/4 of number of pixels in width and height of the rectangle
+                        elementsInRow /= 4;
+                        rows /= 4;
+                    }
+                    var rowSize = elementSize * elementsInRow;
+                    if (rowSize == databox.RowPitch)
+                        stream.ReadRange(data, startIndex, elementCount);
+                    else
+                    {
+                        // Some drivers may add pitch to rows.
+                        // We need to copy each row separatly and skip trailing zeros.
+                        stream.Seek(0, SeekOrigin.Begin);
+
+                        var elementSizeInByte = ReflectionHelpers.SizeOf<T>.Get();
+                        for (var row = 0; row < rows; row++)
+                        {
+                            int i;
+                            for (i = row * rowSize / elementSizeInByte; i < (row + 1) * rowSize / elementSizeInByte; i++)
+                                data[i + startIndex] = stream.Read<T>();
+
+                            if (i >= elementCount)
+                                break;
+
+                            stream.Seek(databox.RowPitch - rowSize, SeekOrigin.Current);
+                        }
+                    }
+                }
+                finally
+                {
+                    SharpDX.Utilities.Dispose( ref stream);
+
+                    d3dContext.UnmapSubresource(_cachedStagingTexture, 0);
+                }
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                SharpDX.Utilities.Dispose(ref _cachedStagingTexture);
+            }
+
+            base.Dispose(disposing);
+        }
+
+        private int CalculateSubresourceIndex(int arraySlice, int level)
+        {
+            return arraySlice * _levelCount + level;
+        }
+
+        private unsafe static Texture2D PlatformFromStream(GraphicsDevice graphicsDevice, Stream stream)
+        {
+            int width, height, channels;
+
+            // The data returned is always four channel BGRA
+            var data = ImageReader.Read(stream, out width, out height, out channels, Imaging.STBI_rgb_alpha);
+
+            // XNA blacks out any pixels with an alpha of zero.
+            if (channels == 4)
+            {
+                fixed (byte* b = &data[0])
+                {
+                    for (var i = 0; i < data.Length; i += 4)
+                    {
+                        if (b[i + 3] == 0)
+                        {
+                            b[i + 0] = 0;
+                            b[i + 1] = 0;
+                            b[i + 2] = 0;
+                        }
+                    }
+                }
+            }
+
+            Texture2D texture = null;
+            texture = new Texture2D(graphicsDevice, width, height);
+            texture.SetData(data);
+
+            return texture;
+        }
+
+        private void PlatformSaveAsJpeg(Stream stream, int width, int height)
+        {
+#if WINDOWS_UAP
+            SaveAsImage(Windows.Graphics.Imaging.BitmapEncoder.JpegEncoderId, stream, width, height);
+#else
+            throw new NotImplementedException();
+#endif
+        }
+
+        //Converts Pixel Data from BGRA to RGBA
+        private static void ConvertToRGBA(int pixelHeight, int pixelWidth, byte[] pixels)
+        {
+            int offset = 0;
+
+            for (int row = 0; row < (uint)pixelHeight; row++)
+            {
+                for (int col = 0; col < (uint)pixelWidth; col++)
+                {
+                    offset = (row * pixelWidth * 4) + (col * 4);
+
+                    byte B = pixels[offset];
+                    byte R = pixels[offset + 2];
+
+                    pixels[offset] = R;
+                    pixels[offset + 2] = B;
+                }
+            }
+        }
+
+        private void PlatformSaveAsPng(Stream stream, int width, int height)
+        {
+            var pngWriter = new PngWriter();
+            pngWriter.Write(this, stream);
+        }
+
+#if WINDOWS_UAP
+        private void SaveAsImage(Guid encoderId, Stream stream, int width, int height)
+        {
+            var pixelData = new byte[Width * Height * GraphicsExtensions.GetSize(Format)];
+            GetData(pixelData);
+
+            // TODO: We need to convert from Format to R8G8B8A8!
+
+            // TODO: We should implement async SaveAsPng() for WinRT.
+            Task.Run(async () =>
+            {
+                // Create a temporary memory stream for writing the png.
+                var memstream = new InMemoryRandomAccessStream();
+
+                // Write the png.
+                var encoder = await Windows.Graphics.Imaging.BitmapEncoder.CreateAsync(encoderId, memstream);
+                encoder.SetPixelData(BitmapPixelFormat.Rgba8, BitmapAlphaMode.Ignore, (uint)width, (uint)height, 96, 96, pixelData);
+                await encoder.FlushAsync();
+
+                // Copy the memory stream into the real output stream.
+                memstream.Seek(0);
+                memstream.AsStreamForRead().CopyTo(stream);
+
+            }).Wait();
+        }
+#endif
+
+        static unsafe SharpDX.Direct3D11.Texture2D CreateTex2DFromBitmap(BitmapSource bsource, GraphicsDevice device)
+        {
+            Texture2DDescription desc;
+            desc.Width = bsource.Size.Width;
+            desc.Height = bsource.Size.Height;
+            desc.ArraySize = 1;
+            desc.BindFlags = BindFlags.ShaderResource;
+            desc.Usage = ResourceUsage.Default;
+            desc.CpuAccessFlags = CpuAccessFlags.None;
+            desc.Format = SharpDX.DXGI.Format.R8G8B8A8_UNorm;
+            desc.MipLevels = 1;
+            desc.OptionFlags = ResourceOptionFlags.None;
+            desc.SampleDescription.Count = 1;
+            desc.SampleDescription.Quality = 0;
+
+            using (DataStream s = new DataStream(bsource.Size.Height * bsource.Size.Width * 4, true, true))
+            {
+                bsource.CopyPixels(bsource.Size.Width * 4, s);
+
+                // XNA blacks out any pixels with an alpha of zero.
+                var data = (byte*)s.DataPointer;
+                for (var i = 0; i < s.Length; i+=4)
+                {
+                    if (data[i + 3] == 0)
+                    {
+                        data[i + 0] = 0;
+                        data[i + 1] = 0;
+                        data[i + 2] = 0;
+                    }
+                }
+
+                DataRectangle rect = new DataRectangle(s.DataPointer, bsource.Size.Width * 4);
+
+                return new SharpDX.Direct3D11.Texture2D(device._d3dDevice, desc, rect);
+            }
+        }
+
+        static ImagingFactory imgfactory;
+        private static BitmapSource LoadBitmap(Stream stream, out SharpDX.WIC.BitmapDecoder decoder)
+        {
+            if (imgfactory == null)
+            {
+                imgfactory = new ImagingFactory();
+            }
+
+            decoder = new SharpDX.WIC.BitmapDecoder(
+                imgfactory,
+                stream,
+                DecodeOptions.CacheOnDemand
+                );
+
+            var fconv = new FormatConverter(imgfactory);
+
+            using (var frame = decoder.GetFrame(0))
+            {
+                fconv.Initialize(
+                    frame,
+                    PixelFormat.Format32bppRGBA,
+                    BitmapDitherType.None,
+                    null,
+                    0.0,
+                    BitmapPaletteType.Custom);
+            }
+            return fconv;
+        }
+
+        protected internal virtual Texture2DDescription GetTexture2DDescription()
+        {
+            var desc = new Texture2DDescription();
+            desc.Width = width;
+            desc.Height = height;
+            desc.MipLevels = _levelCount;
+            desc.ArraySize = ArraySize;
+            desc.Format = SharpDXHelper.ToFormat(_format);
+            desc.BindFlags = BindFlags.ShaderResource;
+            desc.CpuAccessFlags = CpuAccessFlags.None;
+            desc.SampleDescription = CreateSampleDescription();
+            desc.Usage = ResourceUsage.Default;
+            desc.OptionFlags = ResourceOptionFlags.None;
+
+            if (_shared)
+                desc.OptionFlags |= ResourceOptionFlags.Shared;
+
+            return desc;
+        }
+        internal override Resource CreateTexture()
+        {
+            // TODO: Move this to SetData() if we want to make Immutable textures!
+            var desc = GetTexture2DDescription();
+
+            // Save sampling description.
+            _sampleDescription = desc.SampleDescription;
+
+            return new SharpDX.Direct3D11.Texture2D(GraphicsDevice._d3dDevice, desc);
+        }
+
+        protected internal virtual SampleDescription CreateSampleDescription()
+        {
+            return new SampleDescription(1, 0);
+        }
+
+        internal SampleDescription GetTextureSampleDescription()
+        {
+            return _sampleDescription;
+        }
+
+        private void PlatformReload(Stream textureStream)
+        {
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/Texture2D.OpenGL.cs b/MonoGame.Framework/Graphics/Texture2D.OpenGL.cs
new file mode 100644
index 00000000000..a889ff95eee
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Texture2D.OpenGL.cs
@@ -0,0 +1,551 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using MonoGame.Utilities;
+using MonoGame.Utilities.Png;
+
+#if IOS
+using UIKit;
+using CoreGraphics;
+using Foundation;
+using System.Drawing;
+#endif
+
+#if OPENGL
+using MonoGame.OpenGL;
+using GLPixelFormat = MonoGame.OpenGL.PixelFormat;
+using PixelFormat = MonoGame.OpenGL.PixelFormat;
+
+#if ANDROID
+using Android.Graphics;
+#endif
+#endif // OPENGL
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class Texture2D : Texture
+    {
+        private void PlatformConstruct(int width, int height, bool mipmap, SurfaceFormat format, SurfaceType type, bool shared)
+        {
+            this.glTarget = TextureTarget.Texture2D;
+            format.GetGLFormat(GraphicsDevice, out glInternalFormat, out glFormat, out glType);
+            Threading.BlockOnUIThread(() =>
+            {
+                GenerateGLTextureIfRequired();
+                int w = width;
+                int h = height;
+                int level = 0;
+                while (true)
+                {
+                    if (glFormat == (PixelFormat)GLPixelFormat.CompressedTextureFormats)
+                    {
+                        int imageSize = 0;
+                        // PVRTC has explicit calculations for imageSize
+                        // https://www.khronos.org/registry/OpenGL/extensions/IMG/IMG_texture_compression_pvrtc.txt
+                        if (format == SurfaceFormat.RgbPvrtc2Bpp || format == SurfaceFormat.RgbaPvrtc2Bpp)
+                        {
+                            imageSize = (Math.Max(w, 16) * Math.Max(h, 8) * 2 + 7) / 8;
+                        }
+                        else if (format == SurfaceFormat.RgbPvrtc4Bpp || format == SurfaceFormat.RgbaPvrtc4Bpp)
+                        {
+                            imageSize = (Math.Max(w, 8) * Math.Max(h, 8) * 4 + 7) / 8;
+                        }
+                        else
+                        {
+                            int blockSize = format.GetSize();
+                            int blockWidth, blockHeight;
+                            format.GetBlockSize(out blockWidth, out blockHeight);
+                            int wBlocks = (w + (blockWidth - 1)) / blockWidth;
+                            int hBlocks = (h + (blockHeight - 1)) / blockHeight;
+                            imageSize = wBlocks * hBlocks * blockSize;
+                        }
+                        GL.CompressedTexImage2D(TextureTarget.Texture2D, level, glInternalFormat, w, h, 0, imageSize, IntPtr.Zero);
+                        GraphicsExtensions.CheckGLError();
+                    }
+                    else
+                    {
+                        GL.TexImage2D(TextureTarget.Texture2D, level, glInternalFormat, w, h, 0, glFormat, glType, IntPtr.Zero);
+                        GraphicsExtensions.CheckGLError();
+                    }
+
+                    if ((w == 1 && h == 1) || !mipmap)
+                        break;
+                    if (w > 1)
+                        w = w / 2;
+                    if (h > 1)
+                        h = h / 2;
+                    ++level;
+                }
+            });
+        }
+
+        private void PlatformSetData<T>(int level, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            int w, h;
+            GetSizeForLevel(Width, Height, level, out w, out h);
+            Threading.BlockOnUIThread(() =>
+            {
+                var elementSizeInByte = ReflectionHelpers.SizeOf<T>.Get();
+                var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+                // Use try..finally to make sure dataHandle is freed in case of an error
+                try
+                {
+                    var startBytes = startIndex * elementSizeInByte;
+                    var dataPtr = new IntPtr(dataHandle.AddrOfPinnedObject().ToInt64() + startBytes);
+                    // Store the current bound texture.
+                    var prevTexture = GraphicsExtensions.GetBoundTexture2D();
+
+                    if (prevTexture != glTexture)
+                    {
+                        GL.BindTexture(TextureTarget.Texture2D, glTexture);
+                        GraphicsExtensions.CheckGLError();
+                    }
+
+                    GenerateGLTextureIfRequired();
+                    GL.PixelStore(PixelStoreParameter.UnpackAlignment, Math.Min(_format.GetSize(), 8));
+
+                    if (glFormat == (PixelFormat)GLPixelFormat.CompressedTextureFormats)
+                    {
+                        GL.CompressedTexImage2D(TextureTarget.Texture2D, level, glInternalFormat, w, h, 0, elementCount * elementSizeInByte, dataPtr);
+                    }
+                    else
+                    {
+                        GL.TexImage2D(TextureTarget.Texture2D, level, glInternalFormat, w, h, 0, glFormat, glType, dataPtr);
+                    }
+                    GraphicsExtensions.CheckGLError();
+
+#if !ANDROID
+                    // Required to make sure that any texture uploads on a thread are completed
+                    // before the main thread tries to use the texture.
+                    GL.Finish();
+                    GraphicsExtensions.CheckGLError();
+#endif
+                    // Restore the bound texture.
+                    if (prevTexture != glTexture)
+                    {
+                        GL.BindTexture(TextureTarget.Texture2D, prevTexture);
+                        GraphicsExtensions.CheckGLError();
+                    }
+                }
+                finally
+                {
+                    dataHandle.Free();
+                }
+            });
+        }
+
+        private void PlatformSetData<T>(int level, int arraySlice, Rectangle rect, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            Threading.BlockOnUIThread(() =>
+            {
+                var elementSizeInByte = ReflectionHelpers.SizeOf<T>.Get();
+                var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+                // Use try..finally to make sure dataHandle is freed in case of an error
+                try
+                {
+                    var startBytes = startIndex * elementSizeInByte;
+                    var dataPtr = new IntPtr(dataHandle.AddrOfPinnedObject().ToInt64() + startBytes);
+                    // Store the current bound texture.
+                    var prevTexture = GraphicsExtensions.GetBoundTexture2D();
+
+                    if (prevTexture != glTexture)
+                    {
+                        GL.BindTexture(TextureTarget.Texture2D, glTexture);
+                        GraphicsExtensions.CheckGLError();
+                    }
+
+                    GenerateGLTextureIfRequired();
+                    GL.PixelStore(PixelStoreParameter.UnpackAlignment, Math.Min(_format.GetSize(), 8));
+
+                    if (glFormat == (PixelFormat)GLPixelFormat.CompressedTextureFormats)
+                    {
+                        GL.CompressedTexSubImage2D(TextureTarget.Texture2D, level, rect.X, rect.Y, rect.Width, rect.Height,
+                            (PixelInternalFormat)glInternalFormat, elementCount * elementSizeInByte, dataPtr);
+                    }
+                    else
+                    {
+                        GL.TexSubImage2D(TextureTarget.Texture2D, level, rect.X, rect.Y,
+                            rect.Width, rect.Height, glFormat, glType, dataPtr);
+                    }
+                    GraphicsExtensions.CheckGLError();
+
+#if !ANDROID
+                    // Required to make sure that any texture uploads on a thread are completed
+                    // before the main thread tries to use the texture.
+                    GL.Finish();
+                    GraphicsExtensions.CheckGLError();
+#endif
+                    // Restore the bound texture.
+                    if (prevTexture != glTexture)
+                    {
+                        GL.BindTexture(TextureTarget.Texture2D, prevTexture);
+                        GraphicsExtensions.CheckGLError();
+                    }
+                }
+                finally
+                {
+                    dataHandle.Free();
+                }
+            });
+        }
+
+        private void PlatformGetData<T>(int level, int arraySlice, Rectangle rect, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            Threading.EnsureUIThread();
+
+#if GLES
+            // TODO: check for for non renderable formats (formats that can't be attached to FBO)
+
+            var framebufferId = 0;
+            GL.GenFramebuffers(1, out framebufferId);
+            GraphicsExtensions.CheckGLError();
+            GL.BindFramebuffer(FramebufferTarget.Framebuffer, framebufferId);
+            GraphicsExtensions.CheckGLError();
+            GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, TextureTarget.Texture2D, this.glTexture, 0);
+            GraphicsExtensions.CheckGLError();
+
+            GL.ReadPixels(rect.X, rect.Y, rect.Width, rect.Height, this.glFormat, this.glType, data);
+            GraphicsExtensions.CheckGLError();
+            GraphicsDevice.DisposeFramebuffer(framebufferId);
+#else
+            var tSizeInByte = ReflectionHelpers.SizeOf<T>.Get();
+            GL.BindTexture(TextureTarget.Texture2D, this.glTexture);
+            GL.PixelStore(PixelStoreParameter.PackAlignment, Math.Min(tSizeInByte, 8));
+
+            if (glFormat == (PixelFormat) GLPixelFormat.CompressedTextureFormats)
+            {
+                // Note: for compressed format Format.GetSize() returns the size of a 4x4 block
+                var pixelToT = Format.GetSize() / tSizeInByte;
+                var tFullWidth = Math.Max(this.width >> level, 1) / 4 * pixelToT;
+                var temp = new T[Math.Max(this.height >> level, 1) / 4 * tFullWidth];
+                GL.GetCompressedTexImage(TextureTarget.Texture2D, level, temp);
+                GraphicsExtensions.CheckGLError();
+
+                var rowCount = rect.Height / 4;
+                var tRectWidth = rect.Width / 4 * Format.GetSize() / tSizeInByte;
+                for (var r = 0; r < rowCount; r++)
+                {
+                    var tempStart = rect.X / 4 * pixelToT + (rect.Top / 4 + r) * tFullWidth;
+                    var dataStart = startIndex + r * tRectWidth;
+                    Array.Copy(temp, tempStart, data, dataStart, tRectWidth);
+                }
+            }
+            else
+            {
+                // we need to convert from our format size to the size of T here
+                var tFullWidth = Math.Max(this.width >> level, 1) * Format.GetSize() / tSizeInByte;
+                var temp = new T[Math.Max(this.height >> level, 1) * tFullWidth];
+                GL.GetTexImage(TextureTarget.Texture2D, level, glFormat, glType, temp);
+                GraphicsExtensions.CheckGLError();
+
+                var pixelToT = Format.GetSize() / tSizeInByte;
+                var rowCount = rect.Height;
+                var tRectWidth = rect.Width * pixelToT;
+                for (var r = 0; r < rowCount; r++)
+                {
+                    var tempStart = rect.X * pixelToT + (r + rect.Top) * tFullWidth;
+                    var dataStart = startIndex + r * tRectWidth;
+                    Array.Copy(temp, tempStart, data, dataStart, tRectWidth);
+                }
+            }
+#endif
+        }
+
+        private unsafe static Texture2D PlatformFromStream(GraphicsDevice graphicsDevice, Stream stream)
+        {
+            int width, height, channels;
+
+            // The data returned is always four channel BGRA
+            var data = ImageReader.Read(stream, out width, out height, out channels, Imaging.STBI_rgb_alpha);
+
+            // XNA blacks out any pixels with an alpha of zero.
+            if (channels == 4)
+            {
+                fixed (byte* b = &data[0])
+                {
+                    for (var i = 0; i < data.Length; i += 4)
+                    {
+                        if (b[i + 3] == 0)
+                        {
+                            b[i + 0] = 0;
+                            b[i + 1] = 0;
+                            b[i + 2] = 0;
+                        }
+                    }
+                }
+            }
+
+            Texture2D texture = null;
+            texture = new Texture2D(graphicsDevice, width, height);
+            texture.SetData(data);
+
+            return texture;
+        }
+
+#if IOS
+        [CLSCompliant(false)]
+        public static Texture2D FromStream(GraphicsDevice graphicsDevice, UIImage uiImage)
+        {
+            return PlatformFromStream(graphicsDevice, uiImage.CGImage);
+        }
+#elif ANDROID
+        [CLSCompliant(false)]
+        public static Texture2D FromStream(GraphicsDevice graphicsDevice, Bitmap bitmap)
+        {
+            return PlatformFromStream(graphicsDevice, bitmap);
+        }
+
+        [CLSCompliant(false)]
+        public void Reload(Bitmap image)
+        {
+            var width = image.Width;
+            var height = image.Height;
+
+            int[] pixels = new int[width * height];
+            if ((width != image.Width) || (height != image.Height))
+            {
+                using (Bitmap imagePadded = Bitmap.CreateBitmap(width, height, Bitmap.Config.Argb8888))
+                {
+                    Canvas canvas = new Canvas(imagePadded);
+                    canvas.DrawARGB(0, 0, 0, 0);
+                    canvas.DrawBitmap(image, 0, 0, null);
+                    imagePadded.GetPixels(pixels, 0, width, 0, 0, width, height);
+                    imagePadded.Recycle();
+                }
+            }
+            else
+            {
+                image.GetPixels(pixels, 0, width, 0, 0, width, height);
+            }
+
+            image.Recycle();
+
+            this.SetData<int>(pixels);
+        }
+#endif
+
+#if IOS
+        private static Texture2D PlatformFromStream(GraphicsDevice graphicsDevice, CGImage cgImage)
+        {
+			var width = cgImage.Width;
+			var height = cgImage.Height;
+
+            var data = new byte[width * height * 4];
+
+            var colorSpace = CGColorSpace.CreateDeviceRGB();
+            var bitmapContext = new CGBitmapContext(data, width, height, 8, width * 4, colorSpace, CGBitmapFlags.PremultipliedLast);
+            bitmapContext.DrawImage(new RectangleF(0, 0, width, height), cgImage);
+            bitmapContext.Dispose();
+            colorSpace.Dispose();
+
+            Texture2D texture = null;
+            Threading.BlockOnUIThread(() =>
+            {
+                texture = new Texture2D(graphicsDevice, (int)width, (int)height, false, SurfaceFormat.Color);
+                texture.SetData(data);
+            });
+
+            return texture;
+        }
+#elif ANDROID
+        private static Texture2D PlatformFromStream(GraphicsDevice graphicsDevice, Bitmap image)
+        {
+            var width = image.Width;
+            var height = image.Height;
+
+            int[] pixels = new int[width * height];
+            if ((width != image.Width) || (height != image.Height))
+            {
+                using (Bitmap imagePadded = Bitmap.CreateBitmap(width, height, Bitmap.Config.Argb8888))
+                {
+                    Canvas canvas = new Canvas(imagePadded);
+                    canvas.DrawARGB(0, 0, 0, 0);
+                    canvas.DrawBitmap(image, 0, 0, null);
+                    imagePadded.GetPixels(pixels, 0, width, 0, 0, width, height);
+                    imagePadded.Recycle();
+                }
+            }
+            else
+            {
+                image.GetPixels(pixels, 0, width, 0, 0, width, height);
+            }
+            image.Recycle();
+
+            // Convert from ARGB to ABGR
+            ConvertToABGR(height, width, pixels);
+
+            Texture2D texture = null;
+            Threading.BlockOnUIThread(() =>
+            {
+                texture = new Texture2D(graphicsDevice, width, height, false, SurfaceFormat.Color);
+                texture.SetData<int>(pixels);
+            });
+
+            return texture;
+        }
+#endif
+
+        private void FillTextureFromStream(Stream stream)
+        {
+#if ANDROID
+            using (Bitmap image = BitmapFactory.DecodeStream(stream, null, new BitmapFactory.Options
+            {
+                InScaled = false,
+                InDither = false,
+                InJustDecodeBounds = false,
+                InPurgeable = true,
+                InInputShareable = true,
+            }))
+            {
+                var width = image.Width;
+                var height = image.Height;
+
+                int[] pixels = new int[width * height];
+                image.GetPixels(pixels, 0, width, 0, 0, width, height);
+
+                // Convert from ARGB to ABGR
+                ConvertToABGR(height, width, pixels);
+
+                this.SetData<int>(pixels);
+                image.Recycle();
+            }
+#endif
+        }
+
+        private void PlatformSaveAsJpeg(Stream stream, int width, int height)
+        {
+#if DESKTOPGL
+            SaveAsImage(stream, width, height, ImageWriterFormat.Jpg);
+#elif ANDROID
+            SaveAsImage(stream, width, height, Bitmap.CompressFormat.Jpeg);
+#else
+            throw new NotImplementedException();
+#endif
+        }
+
+        private void PlatformSaveAsPng(Stream stream, int width, int height)
+        {
+#if DESKTOPGL
+            SaveAsImage(stream, width, height, ImageWriterFormat.Png);
+#elif ANDROID
+            SaveAsImage(stream, width, height, Bitmap.CompressFormat.Png);
+#else
+            var pngWriter = new PngWriter();
+            pngWriter.Write(this, stream);
+#endif
+        }
+
+#if DESKTOPGL
+        internal void SaveAsImage(Stream stream, int width, int height, ImageWriterFormat format)
+        {
+	        if (stream == null)
+	        {
+		        throw new ArgumentNullException("stream", "'stream' cannot be null (Nothing in Visual Basic)");
+	        }
+	        if (width <= 0)
+	        {
+		        throw new ArgumentOutOfRangeException("width", width, "'width' cannot be less than or equal to zero");
+	        }
+	        if (height <= 0)
+	        {
+		        throw new ArgumentOutOfRangeException("height", height, "'height' cannot be less than or equal to zero");
+	        }
+	        byte[] data = null;
+	        try
+	        {
+		        data = new byte[width * height * 4];
+		        GetData(data);
+
+                var writer = new ImageWriter();
+                writer.Write(data, width, height, 4, format, stream);
+	        }
+	        finally
+	        {
+		        if (data != null)
+		        {
+			        data = null;
+		        }
+	        }
+        }
+#elif ANDROID
+        private void SaveAsImage(Stream stream, int width, int height, Bitmap.CompressFormat format)
+        {
+            int[] data = new int[width * height];
+            GetData(data);
+            // internal structure is BGR while bitmap expects RGB
+            for (int i = 0; i < data.Length; ++i)
+            {
+                uint pixel = (uint)data[i];
+                data[i] = (int)((pixel & 0xFF00FF00) | ((pixel & 0x00FF0000) >> 16) | ((pixel & 0x000000FF) << 16));
+            }
+            using (Bitmap bitmap = Bitmap.CreateBitmap(width, height, Bitmap.Config.Argb8888))
+            {
+                bitmap.SetPixels(data, 0, width, 0, 0, width, height);
+                bitmap.Compress(format, 100, stream);
+                bitmap.Recycle();
+            }
+        }
+#endif
+
+        // This method allows games that use Texture2D.FromStream
+        // to reload their textures after the GL context is lost.
+        private void PlatformReload(Stream textureStream)
+        {
+            var prev = GraphicsExtensions.GetBoundTexture2D();
+
+            GenerateGLTextureIfRequired();
+            FillTextureFromStream(textureStream);
+
+            GL.BindTexture(TextureTarget.Texture2D, prev);
+        }
+
+        private void GenerateGLTextureIfRequired()
+        {
+            if (this.glTexture < 0)
+            {
+                GL.GenTextures(1, out this.glTexture);
+                GraphicsExtensions.CheckGLError();
+
+                // For best compatibility and to keep the default wrap mode of XNA, only set ClampToEdge if either
+                // dimension is not a power of two.
+                var wrap = TextureWrapMode.Repeat;
+                if (((width & (width - 1)) != 0) || ((height & (height - 1)) != 0))
+                    wrap = TextureWrapMode.ClampToEdge;
+
+                GL.BindTexture(TextureTarget.Texture2D, this.glTexture);
+                GraphicsExtensions.CheckGLError();
+                GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter,
+                                (_levelCount > 1) ? (int)TextureMinFilter.LinearMipmapLinear : (int)TextureMinFilter.Linear);
+                GraphicsExtensions.CheckGLError();
+                GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter,
+                                (int)TextureMagFilter.Linear);
+                GraphicsExtensions.CheckGLError();
+                GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)wrap);
+                GraphicsExtensions.CheckGLError();
+                GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)wrap);
+                GraphicsExtensions.CheckGLError();
+                // Set mipmap levels
+#if !GLES
+                GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureBaseLevel, 0);
+#endif
+                GraphicsExtensions.CheckGLError();
+                if (GraphicsDevice.GraphicsCapabilities.SupportsTextureMaxLevel)
+                {
+                    if (_levelCount > 0)
+                    {
+                        GL.TexParameter(TextureTarget.Texture2D, SamplerState.TextureParameterNameTextureMaxLevel, _levelCount - 1);
+                    }
+                    else
+                    {
+                        GL.TexParameter(TextureTarget.Texture2D, SamplerState.TextureParameterNameTextureMaxLevel, 1000);
+                    }
+                    GraphicsExtensions.CheckGLError();
+                }
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Texture2D.Web.cs b/MonoGame.Framework/Graphics/Texture2D.Web.cs
new file mode 100644
index 00000000000..3d42a6747ab
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Texture2D.Web.cs
@@ -0,0 +1,54 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class Texture2D : Texture
+    {
+        private void PlatformConstruct(int width, int height, bool mipmap, SurfaceFormat format, SurfaceType type, bool shared)
+        {
+            
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSetData<T>(int level, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSetData<T>(int level, int arraySlice, Rectangle rect, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformGetData<T>(int level, int arraySlice, Rectangle rect, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            throw new NotImplementedException();
+        }
+
+        private static Texture2D PlatformFromStream(GraphicsDevice graphicsDevice, Stream stream)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSaveAsJpeg(Stream stream, int width, int height)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSaveAsPng(Stream stream, int width, int height)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformReload(Stream textureStream)
+        {
+            throw new NotImplementedException();
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Texture2D.cs b/MonoGame.Framework/Graphics/Texture2D.cs
new file mode 100644
index 00000000000..e2207c04701
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Texture2D.cs
@@ -0,0 +1,404 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class Texture2D : Texture
+    {
+        internal protected enum SurfaceType
+        {
+            Texture,
+            RenderTarget,
+            SwapChainRenderTarget,
+        }
+
+		internal int width;
+		internal int height;
+        internal int ArraySize;
+                
+        internal float TexelWidth { get; private set; }
+        internal float TexelHeight { get; private set; }
+
+        /// <summary>
+        /// Gets the dimensions of the texture
+        /// </summary>
+        public Rectangle Bounds
+        {
+            get
+            {
+				return new Rectangle(0, 0, this.width, this.height);
+            }
+        }
+
+        /// <summary>
+        /// Creates a new texture of the given size
+        /// </summary>
+        /// <param name="graphicsDevice"></param>
+        /// <param name="width"></param>
+        /// <param name="height"></param>
+        public Texture2D(GraphicsDevice graphicsDevice, int width, int height)
+            : this(graphicsDevice, width, height, false, SurfaceFormat.Color, SurfaceType.Texture, false, 1)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new texture of a given size with a surface format and optional mipmaps 
+        /// </summary>
+        /// <param name="graphicsDevice"></param>
+        /// <param name="width"></param>
+        /// <param name="height"></param>
+        /// <param name="mipmap"></param>
+        /// <param name="format"></param>
+        public Texture2D(GraphicsDevice graphicsDevice, int width, int height, bool mipmap, SurfaceFormat format)
+            : this(graphicsDevice, width, height, mipmap, format, SurfaceType.Texture, false, 1)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new texture array of a given size with a surface format and optional mipmaps.
+        /// Throws ArgumentException if the current GraphicsDevice can't work with texture arrays
+        /// </summary>
+        /// <param name="graphicsDevice"></param>
+        /// <param name="width"></param>
+        /// <param name="height"></param>
+        /// <param name="mipmap"></param>
+        /// <param name="format"></param>
+        /// <param name="arraySize"></param>
+        public Texture2D(GraphicsDevice graphicsDevice, int width, int height, bool mipmap, SurfaceFormat format, int arraySize)
+            : this(graphicsDevice, width, height, mipmap, format, SurfaceType.Texture, false, arraySize)
+        {
+            
+        }
+
+        /// <summary>
+        ///  Creates a new texture of a given size with a surface format and optional mipmaps.
+        /// </summary>
+        /// <param name="graphicsDevice"></param>
+        /// <param name="width"></param>
+        /// <param name="height"></param>
+        /// <param name="mipmap"></param>
+        /// <param name="format"></param>
+        /// <param name="type"></param>
+        internal Texture2D(GraphicsDevice graphicsDevice, int width, int height, bool mipmap, SurfaceFormat format, SurfaceType type)
+            : this(graphicsDevice, width, height, mipmap, format, type, false, 1)
+        {
+        }
+        
+        protected Texture2D(GraphicsDevice graphicsDevice, int width, int height, bool mipmap, SurfaceFormat format, SurfaceType type, bool shared, int arraySize)
+		{
+            if (graphicsDevice == null)
+                throw new ArgumentNullException("graphicsDevice", FrameworkResources.ResourceCreationWhenDeviceIsNull);
+            if (width <= 0)
+                throw new ArgumentOutOfRangeException("width","Texture width must be greater than zero");
+            if (height <= 0)
+                throw new ArgumentOutOfRangeException("height","Texture height must be greater than zero");
+            if (arraySize > 1 && !graphicsDevice.GraphicsCapabilities.SupportsTextureArrays)
+                throw new ArgumentException("Texture arrays are not supported on this graphics device", "arraySize");
+
+            this.GraphicsDevice = graphicsDevice;
+            this.width = width;
+            this.height = height;
+            this.TexelWidth = 1f / (float)width;
+            this.TexelHeight = 1f / (float)height;
+
+            this._format = format;
+            this._levelCount = mipmap ? CalculateMipLevels(width, height) : 1;
+            this.ArraySize = arraySize;
+
+            // Texture will be assigned by the swap chain.
+		    if (type == SurfaceType.SwapChainRenderTarget)
+		        return;
+
+            PlatformConstruct(width, height, mipmap, format, type, shared);
+        }
+
+        /// <summary>
+        /// Gets the width of the texture in pixels.
+        /// </summary>
+        public int Width
+        {
+            get
+            {
+                return width;
+            }
+        }
+
+        /// <summary>
+        /// Gets the height of the texture in pixels.
+        /// </summary>
+        public int Height
+        {
+            get
+            {
+                return height;
+            }
+        }
+
+        /// <summary>
+        /// Changes the pixels of the texture
+        /// Throws ArgumentNullException if data is null
+        /// Throws ArgumentException if arraySlice is greater than 0, and the GraphicsDevice does not support texture arrays
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="level">Layer of the texture to modify</param>
+        /// <param name="arraySlice">Index inside the texture array</param>
+        /// <param name="rect">Area to modify</param>
+        /// <param name="data">New data for the texture</param>
+        /// <param name="startIndex">Start position of data</param>
+        /// <param name="elementCount"></param>
+        public void SetData<T>(int level, int arraySlice, Rectangle? rect, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            Rectangle checkedRect;
+            ValidateParams(level, arraySlice, rect, data, startIndex, elementCount, out checkedRect);
+            PlatformSetData(level, arraySlice, checkedRect, data, startIndex, elementCount);
+        }
+
+        /// <summary>
+        /// Changes the pixels of the texture
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="level">Layer of the texture to modify</param>
+        /// <param name="rect">Area to modify</param>
+        /// <param name="data">New data for the texture</param>
+        /// <param name="startIndex">Start position of data</param>
+        /// <param name="elementCount"></param>
+        public void SetData<T>(int level, Rectangle? rect, T[] data, int startIndex, int elementCount) where T : struct 
+        {
+            Rectangle checkedRect;
+            ValidateParams(level, 0, rect, data, startIndex, elementCount, out checkedRect);
+            if (rect.HasValue)
+                PlatformSetData(level, 0, checkedRect, data, startIndex, elementCount);
+            else
+                PlatformSetData(level, data, startIndex, elementCount);
+        }
+
+        /// <summary>
+        /// Changes the texture's pixels
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="data">New data for the texture</param>
+        /// <param name="startIndex">Start position of data</param>
+        /// <param name="elementCount"></param>
+		public void SetData<T>(T[] data, int startIndex, int elementCount) where T : struct
+        {
+            Rectangle checkedRect;
+            ValidateParams(0, 0, null, data, startIndex, elementCount, out checkedRect);
+            PlatformSetData(0, data, startIndex, elementCount);
+        }
+
+		/// <summary>
+        /// Changes the texture's pixels
+        /// </summary>
+        /// <typeparam name="T">New data for the texture</typeparam>
+        /// <param name="data"></param>
+		public void SetData<T>(T[] data) where T : struct
+		{
+            Rectangle checkedRect;
+            ValidateParams(0, 0, null, data, 0, data.Length, out checkedRect);
+            PlatformSetData(0, data, 0, data.Length);
+        }
+
+        /// <summary>
+        /// Retrieves the contents of the texture
+        /// Throws ArgumentException if data is null, data.length is too short or
+        /// if arraySlice is greater than 0 and the GraphicsDevice doesn't support texture arrays
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="level">Layer of the texture</param>
+        /// <param name="arraySlice">Index inside the texture array</param>
+        /// <param name="rect">Area of the texture to retrieve</param>
+        /// <param name="data">Destination array for the data</param>
+        /// <param name="startIndex">Starting index of data where to write the pixel data</param>
+        /// <param name="elementCount">Number of pixels to read</param>
+        public void GetData<T>(int level, int arraySlice, Rectangle? rect, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            Rectangle checkedRect;
+            ValidateParams(level, arraySlice, rect, data, startIndex, elementCount, out checkedRect);
+            PlatformGetData(level, arraySlice, checkedRect, data, startIndex, elementCount);
+        }
+
+        /// <summary>
+        /// Retrieves the contents of the texture
+        /// Throws ArgumentException if data is null, data.length is too short or
+        /// if arraySlice is greater than 0 and the GraphicsDevice doesn't support texture arrays
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="level">Layer of the texture</param>
+        /// <param name="rect">Area of the texture</param>
+        /// <param name="data">Destination array for the texture data</param>
+        /// <param name="startIndex">First position in data where to write the pixel data</param>
+        /// <param name="elementCount">Number of pixels to read</param>
+        public void GetData<T>(int level, Rectangle? rect, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            this.GetData(level, 0, rect, data, startIndex, elementCount);
+        }
+
+        /// <summary>
+        /// Retrieves the contents of the texture
+        /// Throws ArgumentException if data is null, data.length is too short or
+        /// if arraySlice is greater than 0 and the GraphicsDevice doesn't support texture arrays
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="data">Destination array for the texture data</param>
+        /// <param name="startIndex">First position in data where to write the pixel data</param>
+        /// <param name="elementCount">Number of pixels to read</param>
+		public void GetData<T>(T[] data, int startIndex, int elementCount) where T : struct
+		{
+			this.GetData(0, null, data, startIndex, elementCount);
+		}
+
+        /// <summary>
+        /// Retrieves the contents of the texture
+        /// Throws ArgumentException if data is null, data.length is too short or
+        /// if arraySlice is greater than 0 and the GraphicsDevice doesn't support texture arrays
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="data">Destination array for the texture data</param>
+        public void GetData<T> (T[] data) where T : struct
+		{
+		    if (data == null)
+		        throw new ArgumentNullException("data");
+			this.GetData(0, null, data, 0, data.Length);
+		}
+		
+        /// <summary>
+        /// Creates a Texture2D from a stream, supported formats bmp, gif, jpg, png, tif and dds (only for simple textures).
+        /// May work with other formats, but will not work with tga files.
+        /// </summary>
+        /// <param name="graphicsDevice">The graphics device where the texture will be created.</param>
+        /// <param name="stream">The stream from which to read the image data.</param>
+        /// <returns>The <see cref="SurfaceFormat.Color"/> texture created from the image stream.</returns>
+        /// <remarks>Note that different image decoders may generate slight differences between platforms, but perceptually 
+        /// the images should be identical.  This call does not premultiply the image alpha, but areas of zero alpha will
+        /// result in black color data.
+        /// </remarks>
+        public static Texture2D FromStream(GraphicsDevice graphicsDevice, Stream stream)
+		{
+            if (graphicsDevice == null)
+                throw new ArgumentNullException("graphicsDevice");
+            if (stream == null)
+                throw new ArgumentNullException("stream");
+
+            try
+            {
+                return PlatformFromStream(graphicsDevice, stream);
+            }catch(Exception e)
+            {
+                throw new InvalidOperationException("This image format is not supported", e);
+            }
+        }
+
+        /// <summary>
+        /// Converts the texture to a JPG image
+        /// </summary>
+        /// <param name="stream">Destination for the image</param>
+        /// <param name="width"></param>
+        /// <param name="height"></param>
+        public void SaveAsJpeg(Stream stream, int width, int height)
+        {
+            PlatformSaveAsJpeg(stream, width, height);
+        }
+
+        /// <summary>
+        /// Converts the texture to a PNG image
+        /// </summary>
+        /// <param name="stream">Destination for the image</param>
+        /// <param name="width"></param>
+        /// <param name="height"></param>
+        public void SaveAsPng(Stream stream, int width, int height)
+        {
+            PlatformSaveAsPng(stream, width, height);
+        }
+
+        // This method allows games that use Texture2D.FromStream 
+        // to reload their textures after the GL context is lost.
+        public void Reload(Stream textureStream)
+        {
+            PlatformReload(textureStream);
+        }
+
+        //Converts Pixel Data from ARGB to ABGR
+        private static void ConvertToABGR(int pixelHeight, int pixelWidth, int[] pixels)
+        {
+            int pixelCount = pixelWidth * pixelHeight;
+            for (int i = 0; i < pixelCount; ++i)
+            {
+                uint pixel = (uint)pixels[i];
+                pixels[i] = (int)((pixel & 0xFF00FF00) | ((pixel & 0x00FF0000) >> 16) | ((pixel & 0x000000FF) << 16));
+            }
+        }
+
+        private void ValidateParams<T>(int level, int arraySlice, Rectangle? rect, T[] data,
+            int startIndex, int elementCount, out Rectangle checkedRect) where T : struct
+        {
+            var textureBounds = new Rectangle(0, 0, Math.Max(width >> level, 1), Math.Max(height >> level, 1));
+            checkedRect = rect ?? textureBounds;
+            if (level < 0 || level >= LevelCount)
+                throw new ArgumentException("level must be smaller than the number of levels in this texture.", "level");
+            if (arraySlice > 0 && !GraphicsDevice.GraphicsCapabilities.SupportsTextureArrays)
+                throw new ArgumentException("Texture arrays are not supported on this graphics device", "arraySlice");
+            if (arraySlice < 0 || arraySlice >= ArraySize)
+                throw new ArgumentException("arraySlice must be smaller than the ArraySize of this texture and larger than 0.", "arraySlice");
+            if (!textureBounds.Contains(checkedRect) || checkedRect.Width <= 0 || checkedRect.Height <= 0)
+                throw new ArgumentException("Rectangle must be inside the texture bounds", "rect");
+            if (data == null)
+                throw new ArgumentNullException("data");
+            var tSize = ReflectionHelpers.SizeOf<T>.Get();
+            var fSize = Format.GetSize();
+            if (tSize > fSize || fSize % tSize != 0)
+                throw new ArgumentException("Type T is of an invalid size for the format of this texture.", "T");
+            if (startIndex < 0 || startIndex >= data.Length)
+                throw new ArgumentException("startIndex must be at least zero and smaller than data.Length.", "startIndex");
+            if (data.Length < startIndex + elementCount)
+                throw new ArgumentException("The data array is too small.");
+
+            int dataByteSize;
+            if (Format.IsCompressedFormat())
+            {
+                int blockWidth, blockHeight;
+                Format.GetBlockSize(out blockWidth, out blockHeight);
+                int blockWidthMinusOne = blockWidth - 1;
+                int blockHeightMinusOne = blockHeight - 1;
+                // round x and y down to next multiple of block size; width and height up to next multiple of block size
+                var roundedWidth = (checkedRect.Width + blockWidthMinusOne) & ~blockWidthMinusOne;
+                var roundedHeight = (checkedRect.Height + blockHeightMinusOne) & ~blockHeightMinusOne;
+                checkedRect = new Rectangle(checkedRect.X & ~blockWidthMinusOne, checkedRect.Y & ~blockHeightMinusOne,
+#if OPENGL
+                    // OpenGL only: The last two mip levels require the width and height to be
+                    // passed as 2x2 and 1x1, but there needs to be enough data passed to occupy
+                    // a full block.
+                    checkedRect.Width < blockWidth && textureBounds.Width < blockWidth ? textureBounds.Width : roundedWidth,
+                    checkedRect.Height < blockHeight && textureBounds.Height < blockHeight ? textureBounds.Height : roundedHeight);
+#else
+                    roundedWidth, roundedHeight);
+#endif
+                if (Format == SurfaceFormat.RgbPvrtc2Bpp || Format == SurfaceFormat.RgbaPvrtc2Bpp)
+                {
+                    dataByteSize = (Math.Max(checkedRect.Width, 16) * Math.Max(checkedRect.Height, 8) * 2 + 7) / 8;
+                }
+                else if (Format == SurfaceFormat.RgbPvrtc4Bpp || Format == SurfaceFormat.RgbaPvrtc4Bpp)
+                {
+                    dataByteSize = (Math.Max(checkedRect.Width, 8) * Math.Max(checkedRect.Height, 8) * 4 + 7) / 8;
+                }
+                else
+                {
+                    dataByteSize = roundedWidth * roundedHeight * fSize / (blockWidth * blockHeight);
+                }
+            }
+            else
+            {
+                dataByteSize = checkedRect.Width * checkedRect.Height * fSize;
+            }
+            if (elementCount * tSize != dataByteSize)
+                throw new ArgumentException(string.Format("elementCount is not the right size, " +
+                                            "elementCount * sizeof(T) is {0}, but data size is {1}.",
+                                            elementCount * tSize, dataByteSize), "elementCount");
+        }
+	}
+}
diff --git a/MonoGame.Framework/Graphics/Texture3D.DirectX.cs b/MonoGame.Framework/Graphics/Texture3D.DirectX.cs
new file mode 100644
index 00000000000..0d875b7d14e
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Texture3D.DirectX.cs
@@ -0,0 +1,153 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using SharpDX;
+using SharpDX.Direct3D11;
+using MapFlags = SharpDX.Direct3D11.MapFlags;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public partial class Texture3D : Texture
+	{
+        private bool renderTarget;
+        private bool mipMap;
+
+        private void PlatformConstruct(GraphicsDevice graphicsDevice, int width, int height, int depth, bool mipMap, SurfaceFormat format, bool renderTarget)
+        {
+            this.renderTarget = renderTarget;
+            this.mipMap = mipMap;
+
+            if (mipMap)
+                this._levelCount = CalculateMipLevels(width, height, depth);
+
+            // Create texture
+            GetTexture();
+        }
+
+
+        internal override SharpDX.Direct3D11.Resource CreateTexture()
+        {
+            var description = new Texture3DDescription
+            {
+                Width = _width,
+                Height = _height,
+                Depth = _depth,
+                MipLevels = _levelCount,
+                Format = SharpDXHelper.ToFormat(_format),
+                BindFlags = BindFlags.ShaderResource,
+                CpuAccessFlags = CpuAccessFlags.None,
+                Usage = ResourceUsage.Default,
+                OptionFlags = ResourceOptionFlags.None,
+            };
+
+            if (renderTarget)
+            {
+                description.BindFlags |= BindFlags.RenderTarget;
+                if (mipMap)
+                {
+                    // Note: XNA 4 does not have a method Texture.GenerateMipMaps() 
+                    // because generation of mipmaps is not supported on the Xbox 360.
+                    // TODO: New method Texture.GenerateMipMaps() required.
+                    description.OptionFlags |= ResourceOptionFlags.GenerateMipMaps;
+                }
+            }
+
+            return new SharpDX.Direct3D11.Texture3D(GraphicsDevice._d3dDevice, description);
+        }
+
+	    private void PlatformSetData<T>(int level,
+                                     int left, int top, int right, int bottom, int front, int back,
+                                     T[] data, int startIndex, int elementCount, int width, int height, int depth)
+        {
+            var elementSizeInByte = ReflectionHelpers.SizeOf<T>.Get();
+            var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                var dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startIndex * elementSizeInByte);
+
+                int rowPitch = GetPitch(width);
+                int slicePitch = rowPitch * height; // For 3D texture: Size of 2D image.
+                var box = new DataBox(dataPtr, rowPitch, slicePitch);
+
+                int subresourceIndex = level;
+
+                var region = new ResourceRegion(left, top, front, right, bottom, back);
+
+                var d3dContext = GraphicsDevice._d3dContext;
+                lock (d3dContext)
+                    d3dContext.UpdateSubresource(box, GetTexture(), subresourceIndex, region);
+            }
+            finally
+            {
+                dataHandle.Free();
+            }
+        }
+
+        private void PlatformGetData<T>(int level, int left, int top, int right, int bottom, int front, int back, T[] data, int startIndex, int elementCount)
+             where T : struct
+        {
+
+            // Create a temp staging resource for copying the data.
+            // 
+            // TODO: Like in Texture2D, we should probably be pooling these staging resources
+            // and not creating a new one each time.
+            //
+            var desc = new Texture3DDescription
+            {
+                Width = _width,
+                Height = _height,
+                Depth = _depth,
+                MipLevels = 1,
+                Format = SharpDXHelper.ToFormat(_format),
+                BindFlags = BindFlags.None,
+                CpuAccessFlags = CpuAccessFlags.Read,
+                Usage = ResourceUsage.Staging,
+                OptionFlags = ResourceOptionFlags.None,
+            };
+
+            var d3dContext = GraphicsDevice._d3dContext;
+            using (var stagingTex = new SharpDX.Direct3D11.Texture3D(GraphicsDevice._d3dDevice, desc))
+            {
+                lock (d3dContext)
+                {
+                    // Copy the data from the GPU to the staging texture.
+                    d3dContext.CopySubresourceRegion(GetTexture(), level, new ResourceRegion(left, top, front, right, bottom, back), stagingTex, 0);
+
+                    // Copy the data to the array.
+                    DataStream stream = null;
+                    try
+                    {
+                        var databox = d3dContext.MapSubresource(stagingTex, 0, MapMode.Read, MapFlags.None, out stream);
+
+                        // Some drivers may add pitch to rows or slices.
+                        // We need to copy each row separatly and skip trailing zeros.
+                        var currentIndex = startIndex;
+                        var elementSize = _format.GetSize();
+                        var elementsInRow = right - left;
+                        var rowsInSlice = bottom - top;
+                        for (var slice = front; slice < back; slice++)
+                        {
+                            for (var row = top; row < bottom; row++)
+                            {
+                                stream.ReadRange(data, currentIndex, elementsInRow);
+                                stream.Seek(databox.RowPitch - (elementSize * elementsInRow), SeekOrigin.Current);
+                                currentIndex += elementsInRow;
+                            }
+                            stream.Seek(databox.SlicePitch - (databox.RowPitch * rowsInSlice), SeekOrigin.Current);
+                        }
+                    }
+                    finally
+                    {
+                        SharpDX.Utilities.Dispose(ref stream);
+                    }
+                }
+            }
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Texture3D.OpenGL.cs b/MonoGame.Framework/Graphics/Texture3D.OpenGL.cs
new file mode 100644
index 00000000000..050b6091077
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Texture3D.OpenGL.cs
@@ -0,0 +1,72 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public partial class Texture3D : Texture
+	{
+
+        private void PlatformConstruct(GraphicsDevice graphicsDevice, int width, int height, int depth, bool mipMap, SurfaceFormat format, bool renderTarget)
+        {
+#if GLES
+            throw new NotSupportedException("OpenGL ES 2.0 doesn't support 3D textures.");
+#else
+            this.glTarget = TextureTarget.Texture3D;
+
+            Threading.BlockOnUIThread(() =>
+            {
+                GL.GenTextures(1, out this.glTexture);
+                GraphicsExtensions.CheckGLError();
+
+                GL.BindTexture(glTarget, glTexture);
+                GraphicsExtensions.CheckGLError();
+
+                format.GetGLFormat(GraphicsDevice, out glInternalFormat, out glFormat, out glType);
+
+                GL.TexImage3D(glTarget, 0, glInternalFormat, width, height, depth, 0, glFormat, glType, IntPtr.Zero);
+                GraphicsExtensions.CheckGLError();
+            });
+
+            if (mipMap)
+                throw new NotImplementedException("Texture3D does not yet support mipmaps.");
+#endif
+        }
+
+        private void PlatformSetData<T>(int level,
+                                     int left, int top, int right, int bottom, int front, int back,
+                                     T[] data, int startIndex, int elementCount, int width, int height, int depth)
+        {
+#if GLES
+            throw new NotSupportedException("OpenGL ES 2.0 doesn't support 3D textures.");
+#else
+            Threading.BlockOnUIThread(() =>
+            {
+                var elementSizeInByte = Marshal.SizeOf(typeof(T));
+                var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+                var dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startIndex * elementSizeInByte);
+
+                GL.BindTexture(glTarget, glTexture);
+                GraphicsExtensions.CheckGLError();
+                GL.TexSubImage3D(glTarget, level, left, top, front, width, height, depth, glFormat, glType, dataPtr);
+                GraphicsExtensions.CheckGLError();
+
+                dataHandle.Free();
+            });
+#endif
+        }
+
+        private void PlatformGetData<T>(int level, int left, int top, int right, int bottom, int front, int back, T[] data, int startIndex, int elementCount)
+             where T : struct
+        {
+
+            throw new NotImplementedException();
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Texture3D.Web.cs b/MonoGame.Framework/Graphics/Texture3D.Web.cs
new file mode 100644
index 00000000000..c319d721140
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Texture3D.Web.cs
@@ -0,0 +1,57 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public partial class Texture3D : Texture
+	{
+        private void PlatformConstruct(
+            GraphicsDevice graphicsDevice, 
+            int width,
+            int height, 
+            int depth, 
+            bool mipMap, 
+            SurfaceFormat format, 
+            bool renderTarget)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSetData<T>(
+            int level,
+            int left, 
+            int top, 
+            int right, 
+            int bottom, 
+            int front, 
+            int back,
+            T[] data,
+            int startIndex,
+            int elementCount,
+            int width, 
+            int height, 
+            int depth)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformGetData<T>(
+            int level,
+            int left,
+            int top,
+            int right,
+            int bottom,
+            int front,
+            int back, 
+            T[] data, 
+            int startIndex, 
+            int elementCount) where T : struct
+        {
+            throw new NotImplementedException();
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Texture3D.cs b/MonoGame.Framework/Graphics/Texture3D.cs
new file mode 100644
index 00000000000..0e7b4ba26af
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Texture3D.cs
@@ -0,0 +1,165 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public partial class Texture3D : Texture
+	{
+        private int _width;
+        private int _height;
+        private int _depth;
+
+        public int Width
+        {
+            get { return _width; }
+        }
+
+        public int Height
+        {
+            get { return _height; }
+        }
+
+        public int Depth
+        {
+            get { return _depth; }
+        }
+
+		public Texture3D(GraphicsDevice graphicsDevice, int width, int height, int depth, bool mipMap, SurfaceFormat format)
+            : this(graphicsDevice, width, height, depth, mipMap, format, false)
+		{
+		}
+
+		protected Texture3D (GraphicsDevice graphicsDevice, int width, int height, int depth, bool mipMap, SurfaceFormat format, bool renderTarget)
+		{
+		    if (graphicsDevice == null)
+		        throw new ArgumentNullException("graphicsDevice", FrameworkResources.ResourceCreationWhenDeviceIsNull);
+            if (width <= 0)
+                throw new ArgumentOutOfRangeException("width","Texture width must be greater than zero");
+            if (height <= 0)
+                throw new ArgumentOutOfRangeException("height","Texture height must be greater than zero");
+            if (depth <= 0)
+                throw new ArgumentOutOfRangeException("depth","Texture depth must be greater than zero");
+
+		    this.GraphicsDevice = graphicsDevice;
+            this._width = width;
+            this._height = height;
+            this._depth = depth;
+            this._levelCount = 1;
+		    this._format = format;
+
+            PlatformConstruct(graphicsDevice, width, height, depth, mipMap, format, renderTarget);
+        }
+
+        public void SetData<T>(T[] data) where T : struct
+		{
+            if (data == null)
+                throw new ArgumentNullException("data");
+			SetData(data, 0, data.Length);
+		}
+
+		public void SetData<T> (T[] data, int startIndex, int elementCount) where T : struct
+		{
+			SetData(0, 0, 0, Width, Height, 0, Depth, data, startIndex, elementCount);
+		}
+
+		public void SetData<T> (int level,
+		                        int left, int top, int right, int bottom, int front, int back,
+		                        T[] data, int startIndex, int elementCount) where T : struct
+		{
+            ValidateParams(level, left, top, right, bottom, front, back, data, startIndex, elementCount);
+
+            var width = right - left;
+            var height = bottom - top;
+            var depth = back - front;
+
+            PlatformSetData(level, left, top, right, bottom, front, back, data, startIndex, elementCount, width, height, depth);
+		}
+
+        /// <summary>
+        /// Gets a copy of 3D texture data, specifying a mipmap level, source box, start index, and number of elements.
+        /// </summary>
+        /// <typeparam name="T">The type of the elements in the array.</typeparam>
+        /// <param name="level">Mipmap level.</param>
+        /// <param name="left">Position of the left side of the box on the x-axis.</param>
+        /// <param name="top">Position of the top of the box on the y-axis.</param>
+        /// <param name="right">Position of the right side of the box on the x-axis.</param>
+        /// <param name="bottom">Position of the bottom of the box on the y-axis.</param>
+        /// <param name="front">Position of the front of the box on the z-axis.</param>
+        /// <param name="back">Position of the back of the box on the z-axis.</param>
+        /// <param name="data">Array of data.</param>
+        /// <param name="startIndex">Index of the first element to get.</param>
+        /// <param name="elementCount">Number of elements to get.</param>
+        public void GetData<T>(int level, int left, int top, int right, int bottom, int front, int back, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            ValidateParams(level, left, top, right, bottom, front, back, data, startIndex, elementCount);
+            PlatformGetData(level, left, top, right, bottom, front, back, data, startIndex, elementCount);
+        }
+
+        /// <summary>
+        /// Gets a copy of 3D texture data, specifying a start index and number of elements.
+        /// </summary>
+        /// <typeparam name="T">The type of the elements in the array.</typeparam>
+        /// <param name="data">Array of data.</param>
+        /// <param name="startIndex">Index of the first element to get.</param>
+        /// <param name="elementCount">Number of elements to get.</param>
+        public void GetData<T>(T[] data, int startIndex, int elementCount) where T : struct
+        {
+            GetData(0, 0, 0, _width, _height, 0, _depth, data, startIndex, elementCount);
+        }
+
+        /// <summary>
+        /// Gets a copy of 3D texture data.
+        /// </summary>
+        /// <typeparam name="T">The type of the elements in the array.</typeparam>
+        /// <param name="data">Array of data.</param>
+        public void GetData<T>(T[] data) where T : struct
+        {
+            if (data == null)
+                throw new ArgumentNullException("data");
+            GetData(data, 0, data.Length);
+        }
+
+        private void ValidateParams<T>(int level,
+		                        int left, int top, int right, int bottom, int front, int back,
+		                        T[] data, int startIndex, int elementCount) where T : struct
+        {
+            var texWidth = Math.Max(Width >> level, 1);
+            var texHeight = Math.Max(Height >> level, 1);
+            var texDepth = Math.Max(Depth >> level, 1);
+            var width = right - left;
+            var height = bottom - top;
+            var depth = back - front;
+
+            if (left < 0 || top < 0 || back < 0 || right > texWidth || bottom > texHeight || front > texDepth)
+                throw new ArgumentException("Area must remain inside texture bounds");
+            // Disallow negative box size
+            if (left >= right || top >= bottom || front >= back)
+                throw new ArgumentException("Neither box size nor box position can be negative");
+            if (level < 0 || level >= LevelCount)
+                throw new ArgumentException("level must be smaller than the number of levels in this texture.");
+            if (data == null)
+                throw new ArgumentNullException("data");
+            var tSize = ReflectionHelpers.SizeOf<T>.Get();
+            var fSize = Format.GetSize();
+            if (tSize > fSize || fSize % tSize != 0)
+                throw new ArgumentException("Type T is of an invalid size for the format of this texture.", "T");
+            if (startIndex < 0 || startIndex >= data.Length)
+                throw new ArgumentException("startIndex must be at least zero and smaller than data.Length.", "startIndex");
+            if (data.Length < startIndex + elementCount)
+                throw new ArgumentException("The data array is too small.");
+
+            var dataByteSize = width*height*depth*fSize;
+            if (elementCount * tSize != dataByteSize)
+                throw new ArgumentException(string.Format("elementCount is not the right size, " +
+                                            "elementCount * sizeof(T) is {0}, but data size is {1}.",
+                                            elementCount * tSize, dataByteSize), "elementCount");
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/TextureCollection.DirectX.cs b/MonoGame.Framework/Graphics/TextureCollection.DirectX.cs
new file mode 100644
index 00000000000..6cd68880c4d
--- /dev/null
+++ b/MonoGame.Framework/Graphics/TextureCollection.DirectX.cs
@@ -0,0 +1,98 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public sealed partial class TextureCollection
+    {
+        void PlatformInit()
+        {
+        }
+
+        internal void ClearTargets(GraphicsDevice device, RenderTargetBinding[] targets)
+        {
+            if (_applyToVertexStage && !device.GraphicsCapabilities.SupportsVertexTextures)
+                return;
+
+            if (_applyToVertexStage)
+                ClearTargets(targets, device._d3dContext.VertexShader);
+            else
+                ClearTargets(targets, device._d3dContext.PixelShader);
+        }
+
+        private void ClearTargets(RenderTargetBinding[] targets, SharpDX.Direct3D11.CommonShaderStage shaderStage)
+        {
+            // NOTE: We make the assumption here that the caller has
+            // locked the d3dContext for us to use.
+
+            // We assume 4 targets to avoid a loop within a loop below.
+            var target0 = targets[0].RenderTarget;
+            var target1 = targets[1].RenderTarget;
+            var target2 = targets[2].RenderTarget;
+            var target3 = targets[3].RenderTarget;
+
+            // Make one pass across all the texture slots.
+            for (var i = 0; i < _textures.Length; i++)
+            {
+                if (_textures[i] == null)
+                    continue;
+
+                if (_textures[i] != target0 &&
+                    _textures[i] != target1 &&
+                    _textures[i] != target2 &&
+                    _textures[i] != target3)
+                    continue;
+
+                // Immediately clear the texture from the device.
+                _dirty &= ~(1 << i);
+                _textures[i] = null;
+                shaderStage.SetShaderResource(i, null);
+            }
+        }
+
+        void PlatformClear()
+        {
+        }
+
+        void PlatformSetTextures(GraphicsDevice device)
+        {
+            // Skip out if nothing has changed.
+            if (_dirty == 0)
+                return;
+
+            // NOTE: We make the assumption here that the caller has
+            // locked the d3dContext for us to use.
+            SharpDX.Direct3D11.CommonShaderStage shaderStage;
+            if (_applyToVertexStage)
+                shaderStage = device._d3dContext.VertexShader;
+            else
+                shaderStage = device._d3dContext.PixelShader;
+
+            for (var i = 0; i < _textures.Length; i++)
+            {
+                var mask = 1 << i;
+                if ((_dirty & mask) == 0)
+                    continue;
+
+                var tex = _textures[i];
+
+                if (_textures[i] == null || _textures[i].IsDisposed)
+                    shaderStage.SetShaderResource(i, null);
+                else
+                {
+                    shaderStage.SetShaderResource(i, _textures[i].GetShaderResourceView());
+                    unchecked
+                    {
+                        _graphicsDevice._graphicsMetrics._textureCount++;
+                    }
+                }
+                _dirty &= ~mask;
+                if (_dirty == 0)
+                    break;
+            }
+
+            _dirty = 0;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/TextureCollection.OpenGL.cs b/MonoGame.Framework/Graphics/TextureCollection.OpenGL.cs
new file mode 100644
index 00000000000..8ee872fc164
--- /dev/null
+++ b/MonoGame.Framework/Graphics/TextureCollection.OpenGL.cs
@@ -0,0 +1,70 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public sealed partial class TextureCollection
+    {
+        private TextureTarget[] _targets;
+
+        void PlatformInit()
+        {
+            _targets = new TextureTarget[_textures.Length];
+        }
+
+        void PlatformClear()
+        {
+            for (var i = 0; i < _targets.Length; i++)
+                _targets[i] = 0;
+        }
+
+        void PlatformSetTextures(GraphicsDevice device)
+        {
+            // Skip out if nothing has changed.
+            if (_dirty == 0)
+                return;
+
+            for (var i = 0; i < _textures.Length; i++)
+            {
+                var mask = 1 << i;
+                if ((_dirty & mask) == 0)
+                    continue;
+
+                var tex = _textures[i];
+
+                GL.ActiveTexture(TextureUnit.Texture0 + i);
+                GraphicsExtensions.CheckGLError();
+
+                // Clear the previous binding if the 
+                // target is different from the new one.
+                if (_targets[i] != 0 && (tex == null || _targets[i] != tex.glTarget))
+                {
+                    GL.BindTexture(_targets[i], 0);
+                    _targets[i] = 0;
+                    GraphicsExtensions.CheckGLError();
+                }
+
+                if (tex != null)
+                {
+                    _targets[i] = tex.glTarget;
+                    GL.BindTexture(tex.glTarget, tex.glTexture);
+                    GraphicsExtensions.CheckGLError();
+
+                    unchecked
+                    {
+                        _graphicsDevice._graphicsMetrics._textureCount++;
+                    }
+                }
+
+                _dirty &= ~mask;
+                if (_dirty == 0)
+                    break;
+            }
+
+            _dirty = 0;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/TextureCollection.Web.cs b/MonoGame.Framework/Graphics/TextureCollection.Web.cs
new file mode 100644
index 00000000000..3418c68c30d
--- /dev/null
+++ b/MonoGame.Framework/Graphics/TextureCollection.Web.cs
@@ -0,0 +1,26 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public sealed partial class TextureCollection
+    {
+        void PlatformInit()
+        {
+            
+        }
+
+        void PlatformClear()
+        {
+            
+        }
+
+        void PlatformSetTextures(GraphicsDevice device)
+        {
+            
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/TextureCollection.cs b/MonoGame.Framework/Graphics/TextureCollection.cs
new file mode 100644
index 00000000000..1aab9afbee0
--- /dev/null
+++ b/MonoGame.Framework/Graphics/TextureCollection.cs
@@ -0,0 +1,68 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public sealed partial class TextureCollection
+    {
+        private readonly GraphicsDevice _graphicsDevice;
+        private readonly Texture[] _textures;
+        private readonly bool _applyToVertexStage;
+        private int _dirty;
+
+        internal TextureCollection(GraphicsDevice graphicsDevice, int maxTextures, bool applyToVertexStage)
+        {
+            _graphicsDevice = graphicsDevice;
+            _textures = new Texture[maxTextures];
+            _applyToVertexStage = applyToVertexStage;
+            _dirty = int.MaxValue;
+            PlatformInit();
+        }
+
+        public Texture this[int index]
+        {
+            get
+            {
+                return _textures[index];
+            }
+            set
+            {
+                if (_applyToVertexStage && !_graphicsDevice.GraphicsCapabilities.SupportsVertexTextures)
+                    throw new NotSupportedException("Vertex textures are not supported on this device.");
+
+                if (_textures[index] == value)
+                    return;
+
+                _textures[index] = value;
+                _dirty |= 1 << index;
+            }
+        }
+
+        internal void Clear()
+        {
+            for (var i = 0; i < _textures.Length; i++)
+                _textures[i] = null;
+
+            PlatformClear();
+            _dirty = int.MaxValue;
+        }
+
+        /// <summary>
+        /// Marks all texture slots as dirty.
+        /// </summary>
+        internal void Dirty()
+        {
+            _dirty = int.MaxValue;
+        }
+
+        internal void SetTextures(GraphicsDevice device)
+        {
+            if (_applyToVertexStage && !device.GraphicsCapabilities.SupportsVertexTextures)
+                return;
+            PlatformSetTextures(device);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/TextureCube.DirectX.cs b/MonoGame.Framework/Graphics/TextureCube.DirectX.cs
new file mode 100644
index 00000000000..2e1ee8a2856
--- /dev/null
+++ b/MonoGame.Framework/Graphics/TextureCube.DirectX.cs
@@ -0,0 +1,175 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using SharpDX;
+using SharpDX.Direct3D11;
+using SharpDX.DXGI;
+using MapFlags = SharpDX.Direct3D11.MapFlags;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public partial class TextureCube
+	{
+        private bool _renderTarget;
+        private bool _mipMap;
+
+        private void PlatformConstruct(GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat format, bool renderTarget)
+        {
+            _renderTarget = renderTarget;
+            _mipMap = mipMap;
+
+            // Create texture
+            GetTexture();
+        }
+
+        internal override SharpDX.Direct3D11.Resource CreateTexture()
+        {
+            var description = new Texture2DDescription
+            {
+                Width = size,
+                Height = size,
+                MipLevels = _levelCount,
+                ArraySize = 6, // A texture cube is a 2D texture array with 6 textures.
+                Format = SharpDXHelper.ToFormat(_format),
+                BindFlags = BindFlags.ShaderResource,
+                CpuAccessFlags = CpuAccessFlags.None,
+                SampleDescription = { Count = 1, Quality = 0 },
+                Usage = ResourceUsage.Default,
+                OptionFlags = ResourceOptionFlags.TextureCube
+            };
+
+            if (_renderTarget)
+            {
+                description.BindFlags |= BindFlags.RenderTarget;
+                if (_mipMap)
+                    description.OptionFlags |= ResourceOptionFlags.GenerateMipMaps;
+            }
+
+            return new SharpDX.Direct3D11.Texture2D(GraphicsDevice._d3dDevice, description);
+        }
+
+        private void PlatformGetData<T>(CubeMapFace cubeMapFace, int level, Rectangle rect, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            // Create a temp staging resource for copying the data.
+            // 
+            // TODO: Like in Texture2D, we should probably be pooling these staging resources
+            // and not creating a new one each time.
+            //
+            var min = _format.IsCompressedFormat() ? 4 : 1;
+            var levelSize = Math.Max(size >> level, min);
+
+            var desc = new Texture2DDescription
+            {
+                Width = levelSize,
+                Height = levelSize,
+                MipLevels = 1,
+                ArraySize = 1,
+                Format = SharpDXHelper.ToFormat(_format),
+                SampleDescription = new SampleDescription(1, 0),
+                BindFlags = BindFlags.None,
+                CpuAccessFlags = CpuAccessFlags.Read,
+                Usage = ResourceUsage.Staging,
+                OptionFlags = ResourceOptionFlags.None,
+            };
+
+            var d3dContext = GraphicsDevice._d3dContext;
+            using (var stagingTex = new SharpDX.Direct3D11.Texture2D(GraphicsDevice._d3dDevice, desc))
+            {
+                lock (d3dContext)
+                {
+                    // Copy the data from the GPU to the staging texture.
+                    var subresourceIndex = CalculateSubresourceIndex(cubeMapFace, level);
+                    var elementsInRow = rect.Width;
+                    var rows = rect.Height;
+                    var region = new ResourceRegion(rect.Left, rect.Top, 0, rect.Right, rect.Bottom, 1);
+                    d3dContext.CopySubresourceRegion(GetTexture(), subresourceIndex, region, stagingTex, 0);
+
+                    // Copy the data to the array.
+                    DataStream stream = null;
+                    try
+                    {
+                        var databox = d3dContext.MapSubresource(stagingTex, 0, MapMode.Read, MapFlags.None, out stream);
+
+                        var elementSize = _format.GetSize();
+                        if (_format.IsCompressedFormat())
+                        {
+                            // for 4x4 block compression formats an element is one block, so elementsInRow
+                            // and number of rows are 1/4 of number of pixels in width and height of the rectangle
+                            elementsInRow /= 4;
+                            rows /= 4;
+                        }
+                        var rowSize = elementSize * elementsInRow;
+                        if (rowSize == databox.RowPitch)
+                            stream.ReadRange(data, startIndex, elementCount);
+                        else
+                        {
+                            // Some drivers may add pitch to rows.
+                            // We need to copy each row separatly and skip trailing zeros.
+                            stream.Seek(0, SeekOrigin.Begin);
+
+                            var elementSizeInByte = ReflectionHelpers.SizeOf<T>.Get();
+                            for (var row = 0; row < rows; row++)
+                            {
+                                int i;
+                                for (i = row * rowSize / elementSizeInByte; i < (row + 1) * rowSize / elementSizeInByte; i++)
+                                    data[i + startIndex] = stream.Read<T>();
+
+                                if (i >= elementCount)
+                                    break;
+
+                                stream.Seek(databox.RowPitch - rowSize, SeekOrigin.Current);
+                            }
+                        }
+                    }
+                    finally
+                    {
+                        SharpDX.Utilities.Dispose(ref stream);
+                    }
+                }
+            }
+        }
+
+        private void PlatformSetData<T>(CubeMapFace face, int level, Rectangle rect, T[] data, int startIndex, int elementCount)
+        {
+            var elementSizeInByte = ReflectionHelpers.SizeOf<T>.Get();
+            var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+            // Use try..finally to make sure dataHandle is freed in case of an error
+            try
+            {
+                var dataPtr = (IntPtr) (dataHandle.AddrOfPinnedObject().ToInt64() + startIndex*elementSizeInByte);
+                var box = new DataBox(dataPtr, GetPitch(rect.Width), 0);
+
+                var subresourceIndex = CalculateSubresourceIndex(face, level);
+
+                var region = new ResourceRegion
+                {
+                    Top = rect.Top,
+                    Front = 0,
+                    Back = 1,
+                    Bottom = rect.Bottom,
+                    Left = rect.Left,
+                    Right = rect.Right
+                };
+
+                var d3dContext = GraphicsDevice._d3dContext;
+                lock (d3dContext)
+                    d3dContext.UpdateSubresource(box, GetTexture(), subresourceIndex, region);
+            }
+            finally
+            {
+                dataHandle.Free();
+            }
+        }
+
+	    private int CalculateSubresourceIndex(CubeMapFace face, int level)
+	    {
+	        return (int) face * _levelCount + level;
+	    }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/TextureCube.OpenGL.cs b/MonoGame.Framework/Graphics/TextureCube.OpenGL.cs
new file mode 100644
index 00000000000..917a7b5d037
--- /dev/null
+++ b/MonoGame.Framework/Graphics/TextureCube.OpenGL.cs
@@ -0,0 +1,199 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.InteropServices;
+using MonoGame.OpenGL;
+using GLPixelFormat = MonoGame.OpenGL.PixelFormat;
+using PixelFormat = MonoGame.OpenGL.PixelFormat;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public partial class TextureCube
+	{
+        private void PlatformConstruct(GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat format, bool renderTarget)
+        {
+            this.glTarget = TextureTarget.TextureCubeMap;
+
+            Threading.BlockOnUIThread(() =>
+            {
+			    GL.GenTextures(1, out this.glTexture);
+                GraphicsExtensions.CheckGLError();
+                GL.BindTexture(TextureTarget.TextureCubeMap, this.glTexture);
+                GraphicsExtensions.CheckGLError();
+                GL.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureMinFilter,
+                                mipMap ? (int)TextureMinFilter.LinearMipmapLinear : (int)TextureMinFilter.Linear);
+                GraphicsExtensions.CheckGLError();
+                GL.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureMagFilter,
+                                (int)TextureMagFilter.Linear);
+                GraphicsExtensions.CheckGLError();
+                GL.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureWrapS,
+                                (int)TextureWrapMode.ClampToEdge);
+                GraphicsExtensions.CheckGLError();
+                GL.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.TextureWrapT,
+                                (int)TextureWrapMode.ClampToEdge);
+                GraphicsExtensions.CheckGLError();
+
+
+                format.GetGLFormat(GraphicsDevice, out glInternalFormat, out glFormat, out glType);
+
+                for (var i = 0; i < 6; i++)
+                {
+                    var target = GetGLCubeFace((CubeMapFace)i);
+
+                    if (glFormat == (PixelFormat)GLPixelFormat.CompressedTextureFormats)
+                    {
+                        var imageSize = 0;
+                        switch (format)
+                        {
+                            case SurfaceFormat.RgbPvrtc2Bpp:
+                            case SurfaceFormat.RgbaPvrtc2Bpp:
+                                imageSize = (Math.Max(size, 16) * Math.Max(size, 8) * 2 + 7) / 8;
+                                break;
+                            case SurfaceFormat.RgbPvrtc4Bpp:
+                            case SurfaceFormat.RgbaPvrtc4Bpp:
+                                imageSize = (Math.Max(size, 8) * Math.Max(size, 8) * 4 + 7) / 8;
+                                break;
+                            case SurfaceFormat.Dxt1:
+                            case SurfaceFormat.Dxt1a:
+                            case SurfaceFormat.Dxt1SRgb:
+                            case SurfaceFormat.Dxt3:
+                            case SurfaceFormat.Dxt3SRgb:
+                            case SurfaceFormat.Dxt5:
+                            case SurfaceFormat.Dxt5SRgb:
+                            case SurfaceFormat.RgbEtc1:
+                            case SurfaceFormat.RgbaAtcExplicitAlpha:
+                            case SurfaceFormat.RgbaAtcInterpolatedAlpha:
+                                imageSize = (size + 3) / 4 * ((size + 3) / 4) * format.GetSize();
+                                break;
+                            default:
+                                throw new NotSupportedException();
+                        }
+                        GL.CompressedTexImage2D(target, 0, glInternalFormat, size, size, 0, imageSize, IntPtr.Zero);
+                        GraphicsExtensions.CheckGLError();
+                    }
+                    else
+                    {
+                        GL.TexImage2D(target, 0, glInternalFormat, size, size, 0, glFormat, glType, IntPtr.Zero);
+                        GraphicsExtensions.CheckGLError();
+                    }
+                }
+
+                if (mipMap)
+                {
+#if IOS || ANDROID
+                    GL.GenerateMipmap(GenerateMipmapTarget.TextureCubeMap);
+#else
+                    GraphicsDevice.FramebufferHelper.Get().GenerateMipmap((int) glTarget);
+                    // This updates the mipmaps after a change in the base texture
+                    GL.TexParameter(TextureTarget.TextureCubeMap, TextureParameterName.GenerateMipmap, (int)Bool.True);
+#endif
+                    GraphicsExtensions.CheckGLError();
+                }
+            });
+        }
+
+        private void PlatformGetData<T>(CubeMapFace cubeMapFace, int level, Rectangle rect, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            Threading.EnsureUIThread();
+
+#if OPENGL && DESKTOPGL
+            var target = GetGLCubeFace(cubeMapFace);
+            var tSizeInByte = ReflectionHelpers.SizeOf<T>.Get();
+            GL.BindTexture(TextureTarget.TextureCubeMap, this.glTexture);
+
+            if (glFormat == (PixelFormat) GLPixelFormat.CompressedTextureFormats)
+            {
+                // Note: for compressed format Format.GetSize() returns the size of a 4x4 block
+                var pixelToT = Format.GetSize() / tSizeInByte;
+                var tFullWidth = Math.Max(this.size >> level, 1) / 4 * pixelToT;
+                var temp = new T[Math.Max(this.size >> level, 1) / 4 * tFullWidth];
+                GL.GetCompressedTexImage(target, level, temp);
+                GraphicsExtensions.CheckGLError();
+
+                var rowCount = rect.Height / 4;
+                var tRectWidth = rect.Width / 4 * Format.GetSize() / tSizeInByte;
+                for (var r = 0; r < rowCount; r++)
+                {
+                    var tempStart = rect.X / 4 * pixelToT + (rect.Top / 4 + r) * tFullWidth;
+                    var dataStart = startIndex + r * tRectWidth;
+                    Array.Copy(temp, tempStart, data, dataStart, tRectWidth);
+                }
+            }
+            else
+            {
+                // we need to convert from our format size to the size of T here
+                var tFullWidth = Math.Max(this.size >> level, 1) * Format.GetSize() / tSizeInByte;
+                var temp = new T[Math.Max(this.size >> level, 1) * tFullWidth];
+                GL.GetTexImage(target, level, glFormat, glType, temp);
+                GraphicsExtensions.CheckGLError();
+
+                var pixelToT = Format.GetSize() / tSizeInByte;
+                var rowCount = rect.Height;
+                var tRectWidth = rect.Width * pixelToT;
+                for (var r = 0; r < rowCount; r++)
+                {
+                    var tempStart = rect.X * pixelToT + (r + rect.Top) * tFullWidth;
+                    var dataStart = startIndex + r * tRectWidth;
+                    Array.Copy(temp, tempStart, data, dataStart, tRectWidth);
+                }
+            }
+#else
+            throw new NotImplementedException();
+#endif
+        }
+
+        private void PlatformSetData<T>(CubeMapFace face, int level, Rectangle rect, T[] data, int startIndex, int elementCount)
+        {
+            Threading.BlockOnUIThread(() =>
+            {
+                var elementSizeInByte = ReflectionHelpers.SizeOf<T>.Get();
+                var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+                // Use try..finally to make sure dataHandle is freed in case of an error
+                try
+                {
+                    var startBytes = startIndex * elementSizeInByte;
+                    var dataPtr = new IntPtr(dataHandle.AddrOfPinnedObject().ToInt64() + startBytes);
+
+                    GL.BindTexture(TextureTarget.TextureCubeMap, this.glTexture);
+                    GraphicsExtensions.CheckGLError();
+
+                    var target = GetGLCubeFace(face);
+                    if (glFormat == (PixelFormat) GLPixelFormat.CompressedTextureFormats)
+                    {
+                        GL.CompressedTexSubImage2D(target, level, rect.X, rect.Y, rect.Width, rect.Height,
+                            (PixelInternalFormat) glInternalFormat, elementCount * elementSizeInByte, dataPtr);
+                        GraphicsExtensions.CheckGLError();
+                    }
+                    else
+                    {
+                        GL.TexSubImage2D(target, level, rect.X, rect.Y, rect.Width, rect.Height, glFormat, glType,
+                            dataPtr);
+                        GraphicsExtensions.CheckGLError();
+                    }
+                }
+                finally
+                {
+                    dataHandle.Free();
+                }
+            });
+        }
+
+		private TextureTarget GetGLCubeFace(CubeMapFace face)
+        {
+			switch (face)
+            {
+			case CubeMapFace.PositiveX: return TextureTarget.TextureCubeMapPositiveX;
+			case CubeMapFace.NegativeX: return TextureTarget.TextureCubeMapNegativeX;
+			case CubeMapFace.PositiveY: return TextureTarget.TextureCubeMapPositiveY;
+			case CubeMapFace.NegativeY: return TextureTarget.TextureCubeMapNegativeY;
+			case CubeMapFace.PositiveZ: return TextureTarget.TextureCubeMapPositiveZ;
+			case CubeMapFace.NegativeZ: return TextureTarget.TextureCubeMapNegativeZ;
+			}
+			throw new ArgumentException();
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/TextureCube.Web.cs b/MonoGame.Framework/Graphics/TextureCube.Web.cs
new file mode 100644
index 00000000000..415ecf97adf
--- /dev/null
+++ b/MonoGame.Framework/Graphics/TextureCube.Web.cs
@@ -0,0 +1,27 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public partial class TextureCube
+	{
+        private void PlatformConstruct(GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat format, bool renderTarget)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformGetData<T>(CubeMapFace cubeMapFace, int level, Rectangle rect, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSetData<T>(CubeMapFace face, int level, Rectangle rect, T[] data, int startIndex, int elementCount)
+        {
+            throw new NotImplementedException();
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/TextureCube.cs b/MonoGame.Framework/Graphics/TextureCube.cs
new file mode 100644
index 00000000000..6a37e7fbca3
--- /dev/null
+++ b/MonoGame.Framework/Graphics/TextureCube.cs
@@ -0,0 +1,140 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.InteropServices;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public partial class TextureCube : Texture
+	{
+		internal int size;
+
+        /// <summary>
+        /// Gets the width and height of the cube map face in pixels.
+        /// </summary>
+        /// <value>The width and height of a cube map face in pixels.</value>
+        public int Size
+        {
+            get
+            {
+                return size;
+            }
+        }
+		
+		public TextureCube (GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat format)
+            : this(graphicsDevice, size, mipMap, format, false)
+		{
+        }
+
+        internal TextureCube(GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat format, bool renderTarget)
+        {
+            if (graphicsDevice == null)
+                throw new ArgumentNullException("graphicsDevice", FrameworkResources.ResourceCreationWhenDeviceIsNull);
+            if (size <= 0)
+                throw new ArgumentOutOfRangeException("size","Cube size must be greater than zero");
+
+            this.GraphicsDevice = graphicsDevice;
+			this.size = size;
+            this._format = format;
+            this._levelCount = mipMap ? CalculateMipLevels(size) : 1;
+
+            PlatformConstruct(graphicsDevice, size, mipMap, format, renderTarget);
+        }
+
+        /// <summary>
+        /// Gets a copy of cube texture data specifying a cubemap face.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="cubeMapFace">The cube map face.</param>
+        /// <param name="data">The data.</param>
+        public void GetData<T>(CubeMapFace cubeMapFace, T[] data) where T : struct
+        {
+            if (data == null)
+                throw new ArgumentNullException("data");
+            GetData(cubeMapFace, 0, null, data, 0, data.Length);
+        }
+
+	    public void GetData<T>(CubeMapFace cubeMapFace, T[] data, int startIndex, int elementCount) where T : struct
+	    {
+	        GetData(cubeMapFace, 0, null, data, startIndex, elementCount);
+	    }
+
+	    public void GetData<T>(CubeMapFace cubeMapFace, int level, Rectangle? rect, T[] data, int startIndex, int elementCount) where T : struct
+	    {
+            Rectangle checkedRect;
+            ValidateParams(level, rect, data, startIndex, elementCount, out checkedRect);
+	        PlatformGetData(cubeMapFace, level, checkedRect, data, startIndex, elementCount);
+	    }
+
+		public void SetData<T> (CubeMapFace face, T[] data) where T : struct
+		{
+            if (data == null)
+                throw new ArgumentNullException("data");
+            SetData(face, 0, null, data, 0, data.Length);
+		}
+
+        public void SetData<T>(CubeMapFace face, T[] data, int startIndex, int elementCount) where T : struct
+		{
+            SetData(face, 0, null, data, startIndex, elementCount);
+		}
+		
+        public void SetData<T>(CubeMapFace face, int level, Rectangle? rect, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            Rectangle checkedRect;
+            ValidateParams(level, rect, data, startIndex, elementCount, out checkedRect);
+            PlatformSetData(face, level, checkedRect, data, startIndex, elementCount);
+		}
+
+        private void ValidateParams<T>(int level, Rectangle? rect, T[] data, int startIndex,
+            int elementCount, out Rectangle checkedRect) where T : struct
+        {
+            var textureBounds = new Rectangle(0, 0, Math.Max(Size >> level, 1), Math.Max(Size >> level, 1));
+            checkedRect = rect ?? textureBounds;
+            if (level < 0 || level >= LevelCount)
+                throw new ArgumentException("level must be smaller than the number of levels in this texture.");
+            if (!textureBounds.Contains(checkedRect) || checkedRect.Width <= 0 || checkedRect.Height <= 0)
+                throw new ArgumentException("Rectangle must be inside the texture bounds", "rect");
+            if (data == null)
+                throw new ArgumentNullException("data");
+            var tSize = ReflectionHelpers.SizeOf<T>.Get();
+            var fSize = Format.GetSize();
+            if (tSize > fSize || fSize % tSize != 0)
+                throw new ArgumentException("Type T is of an invalid size for the format of this texture.", "T");
+            if (startIndex < 0 || startIndex >= data.Length)
+                throw new ArgumentException("startIndex must be at least zero and smaller than data.Length.", "startIndex");
+            if (data.Length < startIndex + elementCount)
+                throw new ArgumentException("The data array is too small.");
+
+            int dataByteSize;
+            if (Format.IsCompressedFormat())
+            {
+                // round x and y down to next multiple of four; width and height up to next multiple of four
+                var roundedWidth = (checkedRect.Width + 3) & ~0x3;
+                var roundedHeight = (checkedRect.Height + 3) & ~0x3;
+                checkedRect = new Rectangle(checkedRect.X & ~0x3, checkedRect.Y & ~0x3,
+#if OPENGL
+                    // OpenGL only: The last two mip levels require the width and height to be
+                    // passed as 2x2 and 1x1, but there needs to be enough data passed to occupy
+                    // a 4x4 block.
+                    checkedRect.Width < 4 && textureBounds.Width < 4 ? textureBounds.Width : roundedWidth,
+                    checkedRect.Height < 4 && textureBounds.Height < 4 ? textureBounds.Height : roundedHeight);
+#else
+                    roundedWidth, roundedHeight);
+#endif
+                dataByteSize = roundedWidth * roundedHeight * fSize / 16;
+            }
+            else
+            {
+                dataByteSize = checkedRect.Width * checkedRect.Height * fSize;
+            }
+            if (elementCount * tSize != dataByteSize)
+                throw new ArgumentException(string.Format("elementCount is not the right size, " +
+                                            "elementCount * sizeof(T) is {0}, but data size is {1}.",
+                                            elementCount * tSize, dataByteSize), "elementCount");
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Graphics/Vertices/BufferUsage.cs b/MonoGame.Framework/Graphics/Vertices/BufferUsage.cs
new file mode 100644
index 00000000000..ab3ac9d30df
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/BufferUsage.cs
@@ -0,0 +1,21 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// A usage hint for optimizing memory placement of graphics buffers.
+    /// </summary>
+    public enum BufferUsage
+    {
+        /// <summary>
+        /// No special usage.
+        /// </summary>
+        None,
+        /// <summary>
+        /// The buffer will not be readable and will be optimized for rendering and writing.
+        /// </summary>
+        WriteOnly
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/Vertices/DynamicIndexBuffer.cs b/MonoGame.Framework/Graphics/Vertices/DynamicIndexBuffer.cs
new file mode 100644
index 00000000000..144f67af739
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/DynamicIndexBuffer.cs
@@ -0,0 +1,39 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public class DynamicIndexBuffer : IndexBuffer
+	{
+        /// <summary>
+        /// Special offset used internally by GraphicsDevice.DrawUserXXX() methods.
+        /// </summary>
+        internal int UserOffset;
+
+        public bool IsContentLost { get { return false; } }
+		
+		public DynamicIndexBuffer(GraphicsDevice graphicsDevice, IndexElementSize indexElementSize, int indexCount, BufferUsage usage) :
+			base(graphicsDevice, indexElementSize, indexCount, usage, true)
+		{
+		}
+
+   		public DynamicIndexBuffer(GraphicsDevice graphicsDevice, Type indexType, int indexCount, BufferUsage usage) :
+            base(graphicsDevice, indexType, indexCount, usage, true)
+        {
+        }
+
+        public void SetData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, SetDataOptions options) where T : struct
+        {
+            base.SetDataInternal<T>(offsetInBytes, data, startIndex, elementCount, options);
+        }
+
+        public void SetData<T>(T[] data, int startIndex, int elementCount, SetDataOptions options) where T : struct
+        {
+            base.SetDataInternal<T>(0, data, startIndex, elementCount, options);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/Vertices/DynamicVertexBuffer.cs b/MonoGame.Framework/Graphics/Vertices/DynamicVertexBuffer.cs
new file mode 100644
index 00000000000..453ce8f950c
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/DynamicVertexBuffer.cs
@@ -0,0 +1,41 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+	public class DynamicVertexBuffer : VertexBuffer
+    {
+        /// <summary>
+        /// Special offset used internally by GraphicsDevice.DrawUserXXX() methods.
+        /// </summary>
+        internal int UserOffset;
+
+        public bool IsContentLost { get { return false; } }
+
+        public DynamicVertexBuffer(GraphicsDevice graphicsDevice, VertexDeclaration vertexDeclaration, int vertexCount, BufferUsage bufferUsage)
+            : base(graphicsDevice, vertexDeclaration, vertexCount, bufferUsage, true)
+        {
+        }
+		
+		public DynamicVertexBuffer(GraphicsDevice graphicsDevice, Type type, int vertexCount, BufferUsage bufferUsage)
+            : base(graphicsDevice, VertexDeclaration.FromType(type), vertexCount, bufferUsage, true)
+        {
+        }
+
+        public void SetData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride, SetDataOptions options) where T : struct
+        {
+            base.SetDataInternal<T>(offsetInBytes, data, startIndex, elementCount, vertexStride, options);
+        }
+
+        public void SetData<T>(T[] data, int startIndex, int elementCount, SetDataOptions options) where T : struct
+        {
+            var elementSizeInBytes = ReflectionHelpers.SizeOf<T>.Get();
+            base.SetDataInternal<T>(0, data, startIndex, elementCount, elementSizeInBytes, options);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/Vertices/IVertexType.cs b/MonoGame.Framework/Graphics/Vertices/IVertexType.cs
new file mode 100644
index 00000000000..2e3bed806c5
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/IVertexType.cs
@@ -0,0 +1,10 @@
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public interface IVertexType
+    {
+        VertexDeclaration VertexDeclaration
+        {
+            get;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/ImmutableVertexInputLayout.cs b/MonoGame.Framework/Graphics/Vertices/ImmutableVertexInputLayout.cs
new file mode 100644
index 00000000000..81f059478ea
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/ImmutableVertexInputLayout.cs
@@ -0,0 +1,48 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Immutable version of <see cref="VertexInputLayout"/>. Can be used as a key in the
+    /// <see cref="InputLayoutCache"/>.
+    /// </summary>
+    internal sealed class ImmutableVertexInputLayout : VertexInputLayout
+    {
+        private readonly int _hashCode;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ImmutableVertexInputLayout"/> class.
+        /// </summary>
+        /// <param name="vertexDeclarations">The vertex declarations per resource slot.</param>
+        /// <param name="instanceFrequencies">The instance frequencies per resource slot.</param>
+        /// <remarks>
+        /// The specified arrays are stored internally - the arrays are not copied.
+        /// </remarks>
+        public ImmutableVertexInputLayout(VertexDeclaration[] vertexDeclarations, int[] instanceFrequencies)
+            : base(vertexDeclarations, instanceFrequencies, vertexDeclarations.Length)
+        {
+            Debug.Assert(VertexDeclarations.Length == Count);
+            Debug.Assert(InstanceFrequencies.Length == Count);
+
+            // Pre-calculate hash code for fast lookup in dictionary.
+            _hashCode = base.GetHashCode();
+        }
+
+
+        /// <summary>
+        /// Returns a hash code for this instance.
+        /// </summary>
+        /// <returns>
+        /// A hash code for this instance, suitable for use in hashing algorithms and data
+        /// structures like a hash table.
+        /// </returns>
+        public override int GetHashCode()
+        {
+            return _hashCode;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/IndexBuffer.DirectX.cs b/MonoGame.Framework/Graphics/Vertices/IndexBuffer.DirectX.cs
new file mode 100644
index 00000000000..5ec96e075b9
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/IndexBuffer.DirectX.cs
@@ -0,0 +1,172 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.InteropServices;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class IndexBuffer
+    {
+        private SharpDX.Direct3D11.Buffer _buffer;
+
+        internal SharpDX.Direct3D11.Buffer Buffer
+        {
+            get
+            {
+                GenerateIfRequired();
+                return _buffer;
+            }
+        }
+
+        private void PlatformConstruct(IndexElementSize indexElementSize, int indexCount)
+        {
+            GenerateIfRequired();
+        }
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            SharpDX.Utilities.Dispose(ref _buffer);
+        }
+
+        void GenerateIfRequired()
+        {
+            if (_buffer != null)
+                return;
+
+            // TODO: To use true Immutable resources we would need to delay creation of 
+            // the Buffer until SetData() and recreate them if set more than once.
+
+            var sizeInBytes = IndexCount * (this.IndexElementSize == IndexElementSize.SixteenBits ? 2 : 4);
+
+            var accessflags = SharpDX.Direct3D11.CpuAccessFlags.None;
+            var resUsage = SharpDX.Direct3D11.ResourceUsage.Default;
+
+            if (_isDynamic)
+            {
+                accessflags |= SharpDX.Direct3D11.CpuAccessFlags.Write;
+                resUsage = SharpDX.Direct3D11.ResourceUsage.Dynamic;
+            }
+
+            _buffer = new SharpDX.Direct3D11.Buffer(GraphicsDevice._d3dDevice,
+                                                        sizeInBytes,
+                                                        resUsage,
+                                                        SharpDX.Direct3D11.BindFlags.IndexBuffer,
+                                                        accessflags,
+                                                        SharpDX.Direct3D11.ResourceOptionFlags.None,
+                                                        0  // StructureSizeInBytes
+                                                        );
+        }
+
+        private void PlatformGetData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            GenerateIfRequired();
+
+            if (_isDynamic)
+            {
+                throw new NotImplementedException();
+            }
+            else
+            {
+                var deviceContext = GraphicsDevice._d3dContext;
+
+                // Copy the texture to a staging resource
+                var stagingDesc = _buffer.Description;
+                stagingDesc.BindFlags = SharpDX.Direct3D11.BindFlags.None;
+                stagingDesc.CpuAccessFlags = SharpDX.Direct3D11.CpuAccessFlags.Read | SharpDX.Direct3D11.CpuAccessFlags.Write;
+                stagingDesc.Usage = SharpDX.Direct3D11.ResourceUsage.Staging;
+                stagingDesc.OptionFlags = SharpDX.Direct3D11.ResourceOptionFlags.None;
+                using (var stagingBuffer = new SharpDX.Direct3D11.Buffer(GraphicsDevice._d3dDevice, stagingDesc))
+                {
+                    lock (GraphicsDevice._d3dContext)
+                        deviceContext.CopyResource(_buffer, stagingBuffer);
+
+                    int TsizeInBytes = SharpDX.Utilities.SizeOf<T>();
+                    var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+                    try
+                    {
+                        var startBytes = startIndex * TsizeInBytes;
+                        var dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startBytes);
+                        SharpDX.DataPointer DataPointer = new SharpDX.DataPointer(dataPtr, elementCount * TsizeInBytes);
+
+                        lock (GraphicsDevice._d3dContext)
+                        {
+                            // Map the staging resource to a CPU accessible memory
+                            var box = deviceContext.MapSubresource(stagingBuffer, 0, SharpDX.Direct3D11.MapMode.Read, SharpDX.Direct3D11.MapFlags.None);
+
+                            SharpDX.Utilities.CopyMemory(dataPtr, box.DataPointer + offsetInBytes, elementCount * TsizeInBytes);
+
+                            // Make sure that we unmap the resource in case of an exception
+                            deviceContext.UnmapSubresource(stagingBuffer, 0);
+                        }
+                    }
+                    finally
+                    {
+                        dataHandle.Free();
+                    }
+                }
+            }
+        }
+
+        private void PlatformSetDataInternal<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, SetDataOptions options) where T : struct
+        {
+            GenerateIfRequired();
+
+            if (_isDynamic)
+            {
+                // We assume discard by default.
+                var mode = SharpDX.Direct3D11.MapMode.WriteDiscard;
+                if ((options & SetDataOptions.NoOverwrite) == SetDataOptions.NoOverwrite)
+                    mode = SharpDX.Direct3D11.MapMode.WriteNoOverwrite;
+
+                var d3dContext = GraphicsDevice._d3dContext;
+                lock (d3dContext)
+                {
+                    var dataBox = d3dContext.MapSubresource(_buffer, 0, mode, SharpDX.Direct3D11.MapFlags.None);
+                    SharpDX.Utilities.Write(IntPtr.Add(dataBox.DataPointer, offsetInBytes), data, startIndex,
+                                            elementCount);
+                    d3dContext.UnmapSubresource(_buffer, 0);
+                }
+            }
+            else
+            {
+                var elementSizeInBytes = ReflectionHelpers.SizeOf<T>.Get();
+                var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+                try
+                {
+                    var startBytes = startIndex * elementSizeInBytes;
+                    var dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startBytes);
+
+                    var box = new SharpDX.DataBox(dataPtr, elementCount * elementSizeInBytes, 0);
+
+                    var region = new SharpDX.Direct3D11.ResourceRegion();
+                    region.Top = 0;
+                    region.Front = 0;
+                    region.Back = 1;
+                    region.Bottom = 1;
+                    region.Left = offsetInBytes;
+                    region.Right = offsetInBytes + (elementCount * elementSizeInBytes);
+
+                    // TODO: We need to deal with threaded contexts here!
+                    var d3dContext = GraphicsDevice._d3dContext;
+                    lock (d3dContext)
+                        d3dContext.UpdateSubresource(box, _buffer, 0, region);
+                }
+                finally
+                {
+                    dataHandle.Free();
+                }
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+                SharpDX.Utilities.Dispose(ref _buffer);
+
+            base.Dispose(disposing);
+        }
+	}
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/IndexBuffer.OpenGL.cs b/MonoGame.Framework/Graphics/Vertices/IndexBuffer.OpenGL.cs
new file mode 100644
index 00000000000..db78caa401c
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/IndexBuffer.OpenGL.cs
@@ -0,0 +1,148 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Runtime.InteropServices;
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class IndexBuffer
+    {
+		internal int ibo;	
+
+        private void PlatformConstruct(IndexElementSize indexElementSize, int indexCount)
+        {
+            Threading.BlockOnUIThread(GenerateIfRequired);
+        }
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            ibo = 0;
+        }
+
+        /// <summary>
+        /// If the IBO does not exist, create it.
+        /// </summary>
+        void GenerateIfRequired()
+        {
+            if (ibo == 0)
+            {
+                var sizeInBytes = IndexCount * (this.IndexElementSize == IndexElementSize.SixteenBits ? 2 : 4);
+
+                GL.GenBuffers(1, out ibo);
+                GraphicsExtensions.CheckGLError();
+                GL.BindBuffer(BufferTarget.ElementArrayBuffer, ibo);
+                GraphicsExtensions.CheckGLError();
+                GL.BufferData(BufferTarget.ElementArrayBuffer,
+                              (IntPtr)sizeInBytes, IntPtr.Zero, _isDynamic ? BufferUsageHint.StreamDraw : BufferUsageHint.StaticDraw);
+                GraphicsExtensions.CheckGLError();
+            }
+        }
+
+        private void PlatformGetData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount) where T : struct
+        {
+#if GLES
+            // Buffers are write-only on OpenGL ES 1.1 and 2.0.  See the GL_OES_mapbuffer extension for more information.
+            // http://www.khronos.org/registry/gles/extensions/OES/OES_mapbuffer.txt
+            throw new NotSupportedException("Index buffers are write-only on OpenGL ES platforms");
+#endif
+#if !GLES
+            if (Threading.IsOnUIThread())
+            {
+                GetBufferData(offsetInBytes, data, startIndex, elementCount);
+            }
+            else
+            {
+                Threading.BlockOnUIThread(() => GetBufferData(offsetInBytes, data, startIndex, elementCount));
+            }
+#endif
+        }
+
+#if !GLES
+        private void GetBufferData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            GL.BindBuffer(BufferTarget.ElementArrayBuffer, ibo);
+            GraphicsExtensions.CheckGLError();
+            var elementSizeInByte = Marshal.SizeOf(typeof(T));
+            IntPtr ptr = GL.MapBuffer(BufferTarget.ElementArrayBuffer, BufferAccess.ReadOnly);
+            // Pointer to the start of data to read in the index buffer
+            ptr = new IntPtr(ptr.ToInt64() + offsetInBytes);
+			if (typeof(T) == typeof(byte))
+            {
+                byte[] buffer = data as byte[];
+                // If data is already a byte[] we can skip the temporary buffer
+                // Copy from the index buffer to the destination array
+                Marshal.Copy(ptr, buffer, startIndex * elementSizeInByte, elementCount * elementSizeInByte);
+            }
+            else
+            {
+                // Temporary buffer to store the copied section of data
+                byte[] buffer = new byte[elementCount * elementSizeInByte];
+                // Copy from the index buffer to the temporary buffer
+                Marshal.Copy(ptr, buffer, 0, buffer.Length);
+                // Copy from the temporary buffer to the destination array
+                Buffer.BlockCopy(buffer, 0, data, startIndex * elementSizeInByte, elementCount * elementSizeInByte);
+            }
+            GL.UnmapBuffer(BufferTarget.ElementArrayBuffer);
+            GraphicsExtensions.CheckGLError();
+        }
+#endif
+
+        private void PlatformSetDataInternal<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, SetDataOptions options) where T : struct
+        {
+            if (Threading.IsOnUIThread())
+            {
+                BufferData(offsetInBytes, data, startIndex, elementCount, options);
+            }
+            else
+            {
+                Threading.BlockOnUIThread(() => BufferData(offsetInBytes, data, startIndex, elementCount, options));
+            }
+        }
+
+        private void BufferData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, SetDataOptions options) where T : struct
+        {
+            GenerateIfRequired();
+            
+            var elementSizeInByte = Marshal.SizeOf(typeof(T));
+            var sizeInBytes = elementSizeInByte * elementCount;
+            var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+            var dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startIndex * elementSizeInByte);
+            var bufferSize = IndexCount * (IndexElementSize == IndexElementSize.SixteenBits ? 2 : 4);
+            
+            GL.BindBuffer(BufferTarget.ElementArrayBuffer, ibo);
+            GraphicsExtensions.CheckGLError();
+            
+            if (options == SetDataOptions.Discard)
+            {
+                // By assigning NULL data to the buffer this gives a hint
+                // to the device to discard the previous content.
+                GL.BufferData(  BufferTarget.ElementArrayBuffer,
+                              (IntPtr)bufferSize,
+                              IntPtr.Zero,
+                              _isDynamic ? BufferUsageHint.StreamDraw : BufferUsageHint.StaticDraw);
+                GraphicsExtensions.CheckGLError();
+            }
+            
+            GL.BufferSubData(BufferTarget.ElementArrayBuffer, (IntPtr)offsetInBytes, (IntPtr)sizeInBytes, dataPtr);
+            GraphicsExtensions.CheckGLError();
+            
+            dataHandle.Free();
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                if (GraphicsDevice != null)
+                    GraphicsDevice.DisposeBuffer(ibo);
+            }
+            base.Dispose(disposing);
+        }
+	}
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/IndexBuffer.Web.cs b/MonoGame.Framework/Graphics/Vertices/IndexBuffer.Web.cs
new file mode 100644
index 00000000000..443f5d8478e
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/IndexBuffer.Web.cs
@@ -0,0 +1,35 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class IndexBuffer
+    {
+        private void PlatformConstruct(IndexElementSize indexElementSize, int indexCount)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformGetData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSetDataInternal<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, SetDataOptions options) where T : struct
+        {
+            throw new NotImplementedException();
+        }
+	}
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/IndexBuffer.cs b/MonoGame.Framework/Graphics/Vertices/IndexBuffer.cs
new file mode 100644
index 00000000000..4efe628bd35
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/IndexBuffer.cs
@@ -0,0 +1,125 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class IndexBuffer : GraphicsResource
+    {
+        private readonly bool _isDynamic;
+
+        public BufferUsage BufferUsage { get; private set; }
+        public int IndexCount { get; private set; }
+        public IndexElementSize IndexElementSize { get; private set; }
+
+   		protected IndexBuffer(GraphicsDevice graphicsDevice, Type indexType, int indexCount, BufferUsage usage, bool dynamic)
+            : this(graphicsDevice, SizeForType(graphicsDevice, indexType), indexCount, usage, dynamic)
+        {
+        }
+
+		protected IndexBuffer(GraphicsDevice graphicsDevice, IndexElementSize indexElementSize, int indexCount, BufferUsage usage, bool dynamic)
+        {
+			if (graphicsDevice == null)
+            {
+                throw new ArgumentNullException("graphicsDevice", FrameworkResources.ResourceCreationWhenDeviceIsNull);
+            }
+			this.GraphicsDevice = graphicsDevice;
+			this.IndexElementSize = indexElementSize;	
+            this.IndexCount = indexCount;
+            this.BufferUsage = usage;
+			
+            _isDynamic = dynamic;
+
+            PlatformConstruct(indexElementSize, indexCount);
+		}
+
+		public IndexBuffer(GraphicsDevice graphicsDevice, IndexElementSize indexElementSize, int indexCount, BufferUsage bufferUsage) :
+			this(graphicsDevice, indexElementSize, indexCount, bufferUsage, false)
+		{
+		}
+
+		public IndexBuffer(GraphicsDevice graphicsDevice, Type indexType, int indexCount, BufferUsage usage) :
+			this(graphicsDevice, SizeForType(graphicsDevice, indexType), indexCount, usage, false)
+		{
+		}
+
+        /// <summary>
+        /// Gets the relevant IndexElementSize enum value for the given type.
+        /// </summary>
+        /// <param name="graphicsDevice">The graphics device.</param>
+        /// <param name="type">The type to use for the index buffer</param>
+        /// <returns>The IndexElementSize enum value that matches the type</returns>
+        static IndexElementSize SizeForType(GraphicsDevice graphicsDevice, Type type)
+        {
+            switch (ReflectionHelpers.ManagedSizeOf(type))
+            {
+                case 2:
+                    return IndexElementSize.SixteenBits;
+                case 4:
+                    if (graphicsDevice.GraphicsProfile == GraphicsProfile.Reach)
+                        throw new NotSupportedException("The profile does not support an elementSize of IndexElementSize.ThirtyTwoBits; use IndexElementSize.SixteenBits or a type that has a size of two bytes.");
+                    return IndexElementSize.ThirtyTwoBits;
+                default:
+                    throw new ArgumentOutOfRangeException("type","Index buffers can only be created for types that are sixteen or thirty two bits in length");
+            }
+        }
+
+        /// <summary>
+        /// The GraphicsDevice is resetting, so GPU resources must be recreated.
+        /// </summary>
+        internal protected override void GraphicsDeviceResetting()
+        {
+            PlatformGraphicsDeviceResetting();
+        }
+
+        public void GetData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            if (data == null)
+                throw new ArgumentNullException("data");
+            if (data.Length < (startIndex + elementCount))
+                throw new InvalidOperationException("The array specified in the data parameter is not the correct size for the amount of data requested.");
+            if (BufferUsage == BufferUsage.WriteOnly)
+                throw new NotSupportedException("This IndexBuffer was created with a usage type of BufferUsage.WriteOnly. Calling GetData on a resource that was created with BufferUsage.WriteOnly is not supported.");
+
+            PlatformGetData<T>(offsetInBytes, data, startIndex, elementCount);
+        }
+
+        public void GetData<T>(T[] data, int startIndex, int elementCount) where T : struct
+        {
+            this.GetData<T>(0, data, startIndex, elementCount);
+        }
+
+        public void GetData<T>(T[] data) where T : struct
+        {
+            this.GetData<T>(0, data, 0, data.Length);
+        }
+
+        public void SetData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount) where T : struct
+        {
+            SetDataInternal<T>(offsetInBytes, data, startIndex, elementCount, SetDataOptions.None);
+        }
+        		
+		public void SetData<T>(T[] data, int startIndex, int elementCount) where T : struct
+        {
+            SetDataInternal<T>(0, data, startIndex, elementCount, SetDataOptions.None);
+		}
+		
+        public void SetData<T>(T[] data) where T : struct
+        {
+            SetDataInternal<T>(0, data, 0, data.Length, SetDataOptions.None);
+        }
+
+        protected void SetDataInternal<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, SetDataOptions options) where T : struct
+        {
+            if (data == null)
+                throw new ArgumentNullException("data");
+            if (data.Length < (startIndex + elementCount))
+                throw new InvalidOperationException("The array specified in the data parameter is not the correct size for the amount of data requested.");
+
+            PlatformSetDataInternal<T>(offsetInBytes, data, startIndex, elementCount, options);
+        }
+	}
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/IndexElementSize.cs b/MonoGame.Framework/Graphics/Vertices/IndexElementSize.cs
new file mode 100644
index 00000000000..09a3bdfdb4c
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/IndexElementSize.cs
@@ -0,0 +1,21 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines size for index in <see cref="IndexBuffer"/> and <see cref="DynamicIndexBuffer"/>.
+    /// </summary>
+	public enum IndexElementSize
+	{
+        /// <summary>
+        /// 16-bit short/ushort value been used.
+        /// </summary>
+		SixteenBits,
+        /// <summary>
+        /// 32-bit int/uint value been used.
+        /// </summary>
+		ThirtyTwoBits
+	}
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/Vertices/InputLayoutCache.cs b/MonoGame.Framework/Graphics/Vertices/InputLayoutCache.cs
new file mode 100644
index 00000000000..19b488af655
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/InputLayoutCache.cs
@@ -0,0 +1,181 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using SharpDX;
+using SharpDX.Direct3D11;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Caches DirectX input layouts for the input assembler stage.
+    /// </summary>
+    internal class InputLayoutCache : IDisposable
+    {
+#if DEBUG
+        // Flag to print warning only once per shader.
+        private bool _printWarning = true;
+#endif
+        private readonly GraphicsDevice _graphicsDevice;
+        private readonly byte[] _shaderByteCode;
+        private readonly Dictionary<VertexInputLayout, InputLayout> _cache;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InputLayoutCache"/> class.
+        /// </summary>
+        /// <param name="graphicsDevice">The graphics device.</param>
+        /// <param name="shaderByteCode">The byte code of the vertex shader.</param>
+        public InputLayoutCache(GraphicsDevice graphicsDevice, byte[] shaderByteCode)
+        {
+            Debug.Assert(graphicsDevice != null);
+            Debug.Assert(shaderByteCode != null);
+
+            _graphicsDevice = graphicsDevice;
+            _shaderByteCode = shaderByteCode;
+            _cache = new Dictionary<VertexInputLayout, InputLayout>();
+        }
+
+        /// <summary>
+        /// Releases all resources used by an instance of the <see cref="InputLayoutCache"/> class.
+        /// </summary>
+        /// <remarks>
+        /// This method calls the virtual <see cref="Dispose(bool)"/> method, passing in
+        /// <see langword="true"/>, and then suppresses finalization of the instance.
+        /// </remarks>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases the unmanaged resources used by an instance of the
+        /// <see cref="InputLayoutCache"/> class and optionally releases the managed resources.
+        /// </summary>
+        /// <param name="disposing">
+        /// <see langword="true"/> to release both managed and unmanaged resources;
+        /// <see langword="false"/> to release only unmanaged resources.
+        /// </param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                // Dispose managed resources.
+                foreach (var entry in _cache)
+                    entry.Value.Dispose();
+
+                _cache.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Gets or create the DirectX input layout for the specified vertex buffers.
+        /// </summary>
+        /// <param name="vertexBuffers">The vertex buffers.</param>
+        /// <returns>The DirectX input layout.</returns>
+        public InputLayout GetOrCreate(VertexBufferBindings vertexBuffers)
+        {
+            InputLayout inputLayout;
+            if (_cache.TryGetValue(vertexBuffers, out inputLayout))
+                return inputLayout;
+
+            var vertexInputLayout = vertexBuffers.ToImmutable();
+            var inputElements = vertexInputLayout.GetInputElements();
+            try
+            {
+                inputLayout = new InputLayout(_graphicsDevice._d3dDevice, _shaderByteCode, inputElements);
+            }
+            catch (SharpDXException ex)
+            {
+                if (ex.Descriptor != Result.InvalidArg)
+                    throw;
+
+                // If InputLayout ctor fails with InvalidArg then it's most likely because the 
+                // vertex declaration doesn't match the vertex shader. 
+                // Shader probably used the semantic "SV_Position" in the vertex shader input.
+                // Background information:
+                // "SV_Position" is a "system-value semantic" which is interpreted by the
+                // rasterizer stage. This means it needs to be used in the vertex shader output
+                // or the pixel shader input. (See
+                // https://msdn.microsoft.com/en-us/library/windows/desktop/bb509647.aspx)
+                //
+                // However, some effects (notably the original XNA stock effects) use
+                // "SV_Position" for the vertex shader input. This is technically allowed, but
+                // rather uncommon and causes problems:
+                // - XNA/MonoGame only has VertexElementUsage.Position, so there is no way to
+                //   distinguish between "POSITION" and "SV_Position".
+                // - "SV_Position" cannot be used with any index other than 0, i.e. the DirectX
+                //   FX compiler does not accept "SV_Position1", "SV_Position2", ...
+                //   This is a problem when using multiple vertex streams, e.g. for blend shape
+                //   animations. It makes it impossible to correctly match the vertex
+                //   declaration with the vertex shader signature.
+                //
+                // Conclusion:
+                // - MonoGame needs to translate VertexElementUsage.Position to "POSITION".
+                // - MonoGame effects should always use "POSITION" for vertex shader inputs.
+
+                // Here is a workaround ("hack") for old vertex shaders which haven't been
+                // updated: Rename "POSITION0" to "SV_Position" and try again.
+                bool retry = false;
+                for (int i = 0; i < inputElements.Length; i++)
+                {
+                    if (inputElements[i].SemanticIndex == 0 && inputElements[i].SemanticName.Equals("POSITION", StringComparison.OrdinalIgnoreCase))
+                    {
+                        inputElements[i].SemanticName = "SV_Position";
+                        retry = true;
+                        break;
+                    }
+                }
+
+                if (!retry)
+                    throw new InvalidOperationException(GetInvalidArgMessage(inputElements), ex);
+
+                try
+                {
+                    inputLayout = new InputLayout(_graphicsDevice._d3dDevice, _shaderByteCode, inputElements);
+
+                    // Workaround succeeded? This means that there is a vertex shader that needs
+                    // to be updated.
+#if DEBUG
+                    if (_printWarning)
+                    {
+                        Debug.WriteLine(
+                            "Warning: Vertex shader uses semantic 'SV_Position' for input register. " +
+                            "Please update the shader and use the semantic 'POSITION0' instead. The " +
+                            "semantic 'SV_Position' should only be used for the vertex shader output or " +
+                            "pixel shader input!");
+                        _printWarning = false;
+                    }
+#endif
+                }
+                catch (SharpDXException)
+                {
+                    // Workaround failed.
+                    throw new InvalidOperationException(GetInvalidArgMessage(inputElements), ex);
+                }
+            }
+
+            _cache.Add(vertexInputLayout, inputLayout);
+
+            return inputLayout;
+        }
+
+        /// <summary>
+        /// Gets a more helpful message for the SharpDX invalid arg error.
+        /// </summary>
+        /// <param name="inputElements">The input elements.</param>
+        /// <returns>The exception message.</returns>
+        private static string GetInvalidArgMessage(InputElement[] inputElements)
+        {
+            var elements = string.Join(", ", inputElements.Select(x => x.SemanticName + x.SemanticIndex));
+            return "An error occurred while preparing to draw. "
+                   + "This is probably because the current vertex declaration does not include all the elements "
+                   + "required by the current vertex shader. The current vertex declaration includes these elements: "
+                   + elements + ".";
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/PrimitiveType.cs b/MonoGame.Framework/Graphics/Vertices/PrimitiveType.cs
new file mode 100644
index 00000000000..c785aed3ad8
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/PrimitiveType.cs
@@ -0,0 +1,32 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines how vertex data is ordered.
+    /// </summary>
+	public enum PrimitiveType
+	{
+        /// <summary>
+        /// Renders the specified vertices as a sequence of isolated triangles. Each group of three vertices defines a separate triangle. Back-face culling is affected by the current winding-order render state.
+        /// </summary>
+		TriangleList,
+
+        /// <summary>
+        /// Renders the vertices as a triangle strip. The back-face culling flag is flipped automatically on even-numbered triangles.
+        /// </summary>
+		TriangleStrip,
+
+        /// <summary>
+        /// Renders the vertices as a list of isolated straight line segments; the count may be any positive integer.
+        /// </summary>
+		LineList,
+
+        /// <summary>
+        /// Renders the vertices as a single polyline; the count may be any positive integer.
+        /// </summary>
+		LineStrip,
+	}
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexBuffer.DirectX.cs b/MonoGame.Framework/Graphics/Vertices/VertexBuffer.DirectX.cs
new file mode 100644
index 00000000000..260ce259389
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexBuffer.DirectX.cs
@@ -0,0 +1,225 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class VertexBuffer
+    {
+        private SharpDX.Direct3D11.Buffer _buffer;
+
+        private SharpDX.Direct3D11.Buffer _cachedStagingBuffer;
+
+        internal SharpDX.Direct3D11.Buffer Buffer
+        {
+            get
+            {
+                GenerateIfRequired();
+                return _buffer;
+            }
+        }
+
+        private void PlatformConstruct()
+        {
+            GenerateIfRequired();
+        }
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            SharpDX.Utilities.Dispose(ref _buffer);
+        }
+
+        void GenerateIfRequired()
+        {
+            if (_buffer != null)
+                return;
+
+            // TODO: To use Immutable resources we would need to delay creation of 
+            // the Buffer until SetData() and recreate them if set more than once.
+
+            var accessflags = SharpDX.Direct3D11.CpuAccessFlags.None;
+            var usage = SharpDX.Direct3D11.ResourceUsage.Default;
+
+            if (_isDynamic)
+            {
+                accessflags |= SharpDX.Direct3D11.CpuAccessFlags.Write;
+                usage = SharpDX.Direct3D11.ResourceUsage.Dynamic;
+            }
+
+            _buffer = new SharpDX.Direct3D11.Buffer(GraphicsDevice._d3dDevice,
+                                                        VertexDeclaration.VertexStride * VertexCount,
+                                                        usage,
+                                                        SharpDX.Direct3D11.BindFlags.VertexBuffer,
+                                                        accessflags,
+                                                        SharpDX.Direct3D11.ResourceOptionFlags.None,
+                                                        0  // StructureSizeInBytes
+                                                        );
+        }
+
+        void CreatedCachedStagingBuffer()
+        {
+            if (_cachedStagingBuffer != null)
+                return;
+
+            var stagingDesc = _buffer.Description;
+            stagingDesc.BindFlags = SharpDX.Direct3D11.BindFlags.None;
+            stagingDesc.CpuAccessFlags = SharpDX.Direct3D11.CpuAccessFlags.Read | SharpDX.Direct3D11.CpuAccessFlags.Write;
+            stagingDesc.Usage = SharpDX.Direct3D11.ResourceUsage.Staging;
+            stagingDesc.OptionFlags = SharpDX.Direct3D11.ResourceOptionFlags.None;
+
+            _cachedStagingBuffer = new SharpDX.Direct3D11.Buffer(GraphicsDevice._d3dDevice, stagingDesc);
+        }
+
+        private void PlatformGetData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride) where T : struct
+        {
+            GenerateIfRequired();
+
+            if (_isDynamic)
+            {
+                throw new NotImplementedException();
+            }
+            else
+            {
+                var deviceContext = GraphicsDevice._d3dContext;
+
+                if (_cachedStagingBuffer == null)
+                    CreatedCachedStagingBuffer();
+
+                lock (GraphicsDevice._d3dContext)
+                    deviceContext.CopyResource(_buffer, _cachedStagingBuffer);
+
+                int TsizeInBytes = SharpDX.Utilities.SizeOf<T>();
+                var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+
+                try
+                {
+                    var startBytes = startIndex * TsizeInBytes;
+                    var dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startBytes);
+
+                    lock (GraphicsDevice._d3dContext)
+                    {
+                        // Map the staging resource to a CPU accessible memory
+                        var box = deviceContext.MapSubresource(_cachedStagingBuffer, 0, SharpDX.Direct3D11.MapMode.Read, SharpDX.Direct3D11.MapFlags.None);
+
+                        if (vertexStride == TsizeInBytes)
+                        {
+                            SharpDX.Utilities.CopyMemory(dataPtr, box.DataPointer + offsetInBytes, vertexStride * elementCount);
+                        }
+                        else
+                        {
+                            for (int i = 0; i < elementCount; i++)
+                                SharpDX.Utilities.CopyMemory(dataPtr + i * TsizeInBytes, box.DataPointer + i * vertexStride + offsetInBytes, TsizeInBytes);
+                        }
+
+                        // Make sure that we unmap the resource in case of an exception
+                        deviceContext.UnmapSubresource(_cachedStagingBuffer, 0);
+                    }
+                }
+                finally
+                {
+                    dataHandle.Free();
+                }
+            }
+        }
+
+        private void PlatformSetDataInternal<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride, SetDataOptions options, int bufferSize, int elementSizeInBytes) where T : struct
+        {
+            GenerateIfRequired();
+
+            if (_isDynamic)
+            {
+                // We assume discard by default.
+                var mode = SharpDX.Direct3D11.MapMode.WriteDiscard;
+                if ((options & SetDataOptions.NoOverwrite) == SetDataOptions.NoOverwrite)
+                    mode = SharpDX.Direct3D11.MapMode.WriteNoOverwrite;
+
+                var d3dContext = GraphicsDevice._d3dContext;
+                lock (d3dContext)
+                {
+                    var dataBox = d3dContext.MapSubresource(_buffer, 0, mode, SharpDX.Direct3D11.MapFlags.None);
+                    if (vertexStride == elementSizeInBytes)
+					{
+                        SharpDX.Utilities.Write(dataBox.DataPointer + offsetInBytes, data, startIndex, elementCount);
+                    }
+                    else
+                    {
+                        for (int i = 0; i < elementCount; i++)
+                            SharpDX.Utilities.Write(dataBox.DataPointer + offsetInBytes + i * vertexStride, data, startIndex + i, 1);
+                    }
+
+                    d3dContext.UnmapSubresource(_buffer, 0);
+                }
+            }
+            else
+            {
+                var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+                try
+                {
+                    var startBytes = startIndex * elementSizeInBytes;
+                    var dataPtr = (IntPtr)(dataHandle.AddrOfPinnedObject().ToInt64() + startBytes);
+
+                    var d3dContext = GraphicsDevice._d3dContext;
+
+                    if (vertexStride == elementSizeInBytes)
+                    {
+                        var box = new SharpDX.DataBox(dataPtr, elementCount * elementSizeInBytes, 0);
+
+                        var region = new SharpDX.Direct3D11.ResourceRegion();
+                        region.Top = 0;
+                        region.Front = 0;
+                        region.Back = 1;
+                        region.Bottom = 1;
+                        region.Left = offsetInBytes;
+                        region.Right = offsetInBytes + (elementCount * elementSizeInBytes);
+
+                        lock (d3dContext)
+                            d3dContext.UpdateSubresource(box, _buffer, 0, region);
+                    }
+                    else
+                    {
+                        if (_cachedStagingBuffer == null)
+                            CreatedCachedStagingBuffer();
+
+                        lock (d3dContext)
+                        {
+                            d3dContext.CopyResource(_buffer, _cachedStagingBuffer);
+
+                            // Map the staging resource to a CPU accessible memory
+                            var box = d3dContext.MapSubresource(_cachedStagingBuffer, 0, SharpDX.Direct3D11.MapMode.Read,
+                                SharpDX.Direct3D11.MapFlags.None);
+
+                            for (int i = 0; i < elementCount; i++)
+                                SharpDX.Utilities.CopyMemory(
+                                    box.DataPointer + i * vertexStride + offsetInBytes,
+                                    dataPtr + i * elementSizeInBytes, elementSizeInBytes);
+
+                            // Make sure that we unmap the resource in case of an exception
+                            d3dContext.UnmapSubresource(_cachedStagingBuffer, 0);
+
+                            // Copy back from staging resource to real buffer.
+                            d3dContext.CopyResource(_cachedStagingBuffer, _buffer);
+                        }
+                    }
+                }
+                finally
+                {
+                    dataHandle.Free();
+                }
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                SharpDX.Utilities.Dispose(ref _buffer);
+                SharpDX.Utilities.Dispose(ref _cachedStagingBuffer);
+            }
+
+            base.Dispose(disposing);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexBuffer.OpenGL.cs b/MonoGame.Framework/Graphics/Vertices/VertexBuffer.OpenGL.cs
new file mode 100644
index 00000000000..bd792b480a7
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexBuffer.OpenGL.cs
@@ -0,0 +1,183 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Runtime.InteropServices;
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class VertexBuffer
+    {
+		//internal uint vao;
+		internal int vbo;
+
+        private void PlatformConstruct()
+        {
+            Threading.BlockOnUIThread(GenerateIfRequired);
+        }
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            vbo = 0;
+        }
+
+        /// <summary>
+        /// If the VBO does not exist, create it.
+        /// </summary>
+        void GenerateIfRequired()
+        {
+            if (vbo == 0)
+            {
+                //GLExt.Oes.GenVertexArrays(1, out this.vao);
+                //GLExt.Oes.BindVertexArray(this.vao);
+                GL.GenBuffers(1, out this.vbo);
+                GraphicsExtensions.CheckGLError();
+                GL.BindBuffer(BufferTarget.ArrayBuffer, this.vbo);
+                GraphicsExtensions.CheckGLError();
+                GL.BufferData(BufferTarget.ArrayBuffer,
+                              new IntPtr(VertexDeclaration.VertexStride * VertexCount), IntPtr.Zero,
+                              _isDynamic ? BufferUsageHint.StreamDraw : BufferUsageHint.StaticDraw);
+                GraphicsExtensions.CheckGLError();
+            }
+        }
+
+        private void PlatformGetData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride) where T : struct
+        {
+#if GLES
+            // Buffers are write-only on OpenGL ES 1.1 and 2.0.  See the GL_OES_mapbuffer extension for more information.
+            // http://www.khronos.org/registry/gles/extensions/OES/OES_mapbuffer.txt
+            throw new NotSupportedException("Vertex buffers are write-only on OpenGL ES platforms");
+#else
+            Threading.BlockOnUIThread (() => GetBufferData(offsetInBytes, data, startIndex, elementCount, vertexStride));
+#endif
+        }
+
+#if !GLES
+
+        private void GetBufferData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride) where T : struct
+        {
+            GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
+            GraphicsExtensions.CheckGLError();
+
+            // Pointer to the start of data in the vertex buffer
+            var ptr = GL.MapBuffer(BufferTarget.ArrayBuffer, BufferAccess.ReadOnly);
+            GraphicsExtensions.CheckGLError();
+
+            ptr = (IntPtr) (ptr.ToInt64() + offsetInBytes);
+
+            if (typeof(T) == typeof(byte) && vertexStride == 1)
+            {
+                // If data is already a byte[] and stride is 1 we can skip the temporary buffer
+                var buffer = data as byte[];
+                Marshal.Copy(ptr, buffer, startIndex * vertexStride, elementCount * vertexStride);
+            }
+            else
+            {
+                // Temporary buffer to store the copied section of data
+                var tmp = new byte[elementCount * vertexStride];
+                // Copy from the vertex buffer to the temporary buffer
+                Marshal.Copy(ptr, tmp, 0, tmp.Length);
+
+                // Copy from the temporary buffer to the destination array
+                var tmpHandle = GCHandle.Alloc(tmp, GCHandleType.Pinned);
+                var tmpPtr = tmpHandle.AddrOfPinnedObject();
+                try
+                {
+                    for (var i = 0; i < elementCount; i++)
+                    {
+                        data[startIndex + i] = (T) Marshal.PtrToStructure(tmpPtr, typeof(T));
+                        tmpPtr = (IntPtr) (tmpPtr.ToInt64() + vertexStride);
+                    }
+                }
+                finally
+                {
+                    tmpHandle.Free();
+                }
+            }
+
+            GL.UnmapBuffer(BufferTarget.ArrayBuffer);
+            GraphicsExtensions.CheckGLError();
+        }
+        
+#endif
+
+        private void PlatformSetDataInternal<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride, SetDataOptions options, int bufferSize, int elementSizeInBytes) where T : struct
+        {
+            Threading.BlockOnUIThread(() => SetBufferData(bufferSize, elementSizeInBytes, offsetInBytes, data, startIndex, elementCount, vertexStride, options));
+        }
+
+        private void SetBufferData<T>(int bufferSize, int elementSizeInBytes, int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride, SetDataOptions options) where T : struct
+        {
+            GenerateIfRequired();
+
+            GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
+            GraphicsExtensions.CheckGLError();
+            
+            if (options == SetDataOptions.Discard)
+            {
+                // By assigning NULL data to the buffer this gives a hint
+                // to the device to discard the previous content.
+                GL.BufferData(  BufferTarget.ArrayBuffer,
+                              (IntPtr)bufferSize, 
+                              IntPtr.Zero,
+                              _isDynamic ? BufferUsageHint.StreamDraw : BufferUsageHint.StaticDraw);
+                GraphicsExtensions.CheckGLError();
+            }
+
+            var elementSizeInByte = Marshal.SizeOf(typeof(T));
+            if (elementSizeInByte == vertexStride || elementSizeInByte % vertexStride == 0)
+            {
+                // there are no gaps so we can copy in one go
+                var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+                var dataPtr = (IntPtr) (dataHandle.AddrOfPinnedObject().ToInt64() + startIndex * elementSizeInBytes);
+                try
+                {
+                    GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr) offsetInBytes, (IntPtr) (elementSizeInBytes * elementCount), dataPtr);
+                    GraphicsExtensions.CheckGLError();
+                }
+                finally
+                {
+                    dataHandle.Free();
+                }
+            }
+            else
+            {
+                // else we must copy each element separately
+                var dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
+                try
+                {
+                    var dstOffset = offsetInBytes;
+                    var dataPtr = (IntPtr) (dataHandle.AddrOfPinnedObject().ToInt64() + startIndex * elementSizeInByte);
+                    for (var i = 0; i < elementCount; i++)
+                    {
+                        GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr) dstOffset, (IntPtr) elementSizeInByte, dataPtr);
+                        GraphicsExtensions.CheckGLError();
+
+                        dstOffset += vertexStride;
+                        dataPtr = (IntPtr) (dataPtr.ToInt64() + elementSizeInByte);
+                    }
+                }
+                finally
+                {
+                    dataHandle.Free();
+                }
+            }
+
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                if (GraphicsDevice != null)
+                    GraphicsDevice.DisposeBuffer(vbo);
+            }
+            base.Dispose(disposing);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexBuffer.Web.cs b/MonoGame.Framework/Graphics/Vertices/VertexBuffer.Web.cs
new file mode 100644
index 00000000000..35e2b5b1fc6
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexBuffer.Web.cs
@@ -0,0 +1,48 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class VertexBuffer
+    {
+        private void PlatformConstruct()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformGetData<T>(
+            int offsetInBytes,
+            T[] data,
+            int startIndex,
+            int elementCount,
+            int vertexStride)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSetDataInternal<T>(
+            int offsetInBytes,
+            T[] data,
+            int startIndex,
+            int elementCount,
+            int vertexStride,
+            SetDataOptions options,
+            int bufferSize,
+            int elementSizeInBytes)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformGraphicsDeviceResetting()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexBuffer.cs b/MonoGame.Framework/Graphics/Vertices/VertexBuffer.cs
new file mode 100644
index 00000000000..908308de4de
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexBuffer.cs
@@ -0,0 +1,217 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class VertexBuffer : GraphicsResource
+    {
+        private readonly bool _isDynamic;
+
+		public int VertexCount { get; private set; }
+		public VertexDeclaration VertexDeclaration { get; private set; }
+		public BufferUsage BufferUsage { get; private set; }
+		
+		protected VertexBuffer(GraphicsDevice graphicsDevice, VertexDeclaration vertexDeclaration, int vertexCount, BufferUsage bufferUsage, bool dynamic)
+		{
+		    if (graphicsDevice == null)
+		    {
+		        throw new ArgumentNullException("graphicsDevice", FrameworkResources.ResourceCreationWhenDeviceIsNull);
+		    }
+		    this.GraphicsDevice = graphicsDevice;
+            this.VertexDeclaration = vertexDeclaration;
+            this.VertexCount = vertexCount;
+            this.BufferUsage = bufferUsage;
+
+            // Make sure the graphics device is assigned in the vertex declaration.
+            if (vertexDeclaration.GraphicsDevice != graphicsDevice)
+                vertexDeclaration.GraphicsDevice = graphicsDevice;
+
+            _isDynamic = dynamic;
+
+            PlatformConstruct();
+		}
+
+        public VertexBuffer(GraphicsDevice graphicsDevice, VertexDeclaration vertexDeclaration, int vertexCount, BufferUsage bufferUsage) :
+			this(graphicsDevice, vertexDeclaration, vertexCount, bufferUsage, false)
+        {
+        }
+		
+		public VertexBuffer(GraphicsDevice graphicsDevice, Type type, int vertexCount, BufferUsage bufferUsage) :
+			this(graphicsDevice, VertexDeclaration.FromType(type), vertexCount, bufferUsage, false)
+		{
+        }
+
+        /// <summary>
+        /// The GraphicsDevice is resetting, so GPU resources must be recreated.
+        /// </summary>
+        internal protected override void GraphicsDeviceResetting()
+        {
+            PlatformGraphicsDeviceResetting();
+        }
+
+        /// <summary>
+        /// Get the vertex data froom this VertexBuffer.
+        /// </summary>
+        /// <typeparam name="T">The struct you want to fill.</typeparam>
+        /// <param name="offsetInBytes">The offset to the first element in the vertex buffer in bytes.</param>
+        /// <param name="data">An array of T's to be filled.</param>
+        /// <param name="startIndex">The index to start filling the data array.</param>
+        /// <param name="elementCount">The number of T's to get.</param>
+        /// <param name="vertexStride">The size of how a vertex buffer element should be interpreted.</param>
+        ///
+        /// <remarks>
+        /// Note that this pulls data from VRAM into main memory and because of that is a very expensive operation.
+        /// It is often a better idea to keep a copy of the data in main memory.
+        /// </remarks>
+        ///
+        /// <remarks>
+        /// <p>Using this operation it is easy to get certain vertex elements from a VertexBuffer.</p>
+        /// <p>
+        /// For example to get the texture coordinates from a VertexBuffer of <see cref="VertexPositionTexture"/> you can call 
+        /// GetData(4 * 3, data, elementCount, 20). 'data'should be an array of <see cref="Vector2"/> in this example.
+        /// The offsetInBytes is the number of bytes taken up by the <see cref="VertexPositionTexture.Position"/> of the vertex.
+        /// For vertexStride we pass the size of a <see cref="VertexPositionTexture"/>.
+        /// </p>
+        /// </remarks>
+        public void GetData<T> (int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride = 0) where T : struct
+        {
+            var elementSizeInBytes = ReflectionHelpers.SizeOf<T>.Get();
+            if (vertexStride == 0)
+                vertexStride = elementSizeInBytes;
+
+            var vertexByteSize = VertexCount * VertexDeclaration.VertexStride;
+            if (vertexStride > vertexByteSize)
+                throw new ArgumentOutOfRangeException("vertexStride", "Vertex stride can not be larger than the vertex buffer size.");
+
+            if (data == null)
+                throw new ArgumentNullException("data");
+            if (data.Length < (startIndex + elementCount))
+                throw new ArgumentOutOfRangeException("elementCount", "This parameter must be a valid index within the array.");
+            if (BufferUsage == BufferUsage.WriteOnly)
+                throw new NotSupportedException("Calling GetData on a resource that was created with BufferUsage.WriteOnly is not supported.");
+			if (elementCount > 1 && elementCount * vertexStride > vertexByteSize)
+                throw new InvalidOperationException("The array is not the correct size for the amount of data requested.");
+
+            PlatformGetData<T>(offsetInBytes, data, startIndex, elementCount, vertexStride);
+        }
+
+        public void GetData<T>(T[] data, int startIndex, int elementCount) where T : struct
+        {
+            this.GetData<T>(0, data, startIndex, elementCount, 0);
+        }
+
+        public void GetData<T>(T[] data) where T : struct
+        {
+            var elementSizeInByte = ReflectionHelpers.SizeOf<T>.Get();
+            this.GetData<T>(0, data, 0, data.Length, elementSizeInByte);
+        }
+
+        /// <summary>
+        /// Sets the vertex buffer data, specifying the index at which to start copying from the source data array,
+        /// the number of elements to copy from the source data array, 
+        /// and how far apart elements from the source data array should be when they are copied into the vertex buffer.
+        /// </summary>
+        /// <typeparam name="T">Type of elements in the data array.</typeparam>
+        /// <param name="offsetInBytes">Offset in bytes from the beginning of the vertex buffer to the start of the copied data.</param>
+        /// <param name="data">Data array.</param>
+        /// <param name="startIndex">Index at which to start copying from <paramref name="data"/>.
+        /// Must be within the <paramref name="data"/> array bounds.</param>
+        /// <param name="elementCount">Number of elements to copy from <paramref name="data"/>.
+        /// The combination of <paramref name="startIndex"/> and <paramref name="elementCount"/> 
+        /// must be within the <paramref name="data"/> array bounds.</param>
+        /// <param name="vertexStride">Specifies how far apart, in bytes, elements from <paramref name="data"/> should be when 
+        /// they are copied into the vertex buffer.
+        /// In almost all cases this should be <c>sizeof(T)</c>, to create a tightly-packed vertex buffer.
+        /// If you specify <c>sizeof(T)</c>, elements from <paramref name="data"/> will be copied into the 
+        /// vertex buffer with no padding between each element.
+        /// If you specify a value greater than <c>sizeof(T)</c>, elements from <paramref name="data"/> will be copied 
+        /// into the vertex buffer with padding between each element.
+        /// If you specify <c>0</c> for this parameter, it will be treated as if you had specified <c>sizeof(T)</c>.
+        /// With the exception of <c>0</c>, you must specify a value greater than or equal to <c>sizeof(T)</c>.</param>
+        /// <remarks>
+        /// If <c>T</c> is <c>VertexPositionTexture</c>, but you want to set only the position component of the vertex data,
+        /// you would call this method as follows:
+        /// <code>
+        /// Vector3[] positions = new Vector3[numVertices];
+        /// vertexBuffer.SetData(0, positions, 0, numVertices, vertexBuffer.VertexDeclaration.VertexStride);
+        /// </code>
+        /// 
+        /// Continuing from the previous example, if you want to set only the texture coordinate component of the vertex data,
+        /// you would call this method as follows (note the use of <paramref name="offsetInBytes"/>:
+        /// <code>
+        /// Vector2[] texCoords = new Vector2[numVertices];
+        /// vertexBuffer.SetData(12, texCoords, 0, numVertices, vertexBuffer.VertexDeclaration.VertexStride);
+        /// </code>
+        /// </remarks>
+        /// <remarks>
+        /// If you provide a <c>byte[]</c> in the <paramref name="data"/> parameter, then you should almost certainly
+        /// set <paramref name="vertexStride"/> to <c>1</c>, to avoid leaving any padding between the <c>byte</c> values
+        /// when they are copied into the vertex buffer.
+        /// </remarks>
+        public void SetData<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride) where T : struct
+        {
+            SetDataInternal<T>(offsetInBytes, data, startIndex, elementCount, vertexStride, SetDataOptions.None);
+        }
+
+        /// <summary>
+        /// Sets the vertex buffer data, specifying the index at which to start copying from the source data array,
+        /// and the number of elements to copy from the source data array. This is the same as calling 
+        /// <see cref="SetData{T}(int, T[], int, int, int)"/>  with <c>offsetInBytes</c> equal to <c>0</c>,
+        /// and <c>vertexStride</c> equal to <c>sizeof(T)</c>.
+        /// </summary>
+        /// <typeparam name="T">Type of elements in the data array.</typeparam>
+        /// <param name="data">Data array.</param>
+        /// <param name="startIndex">Index at which to start copying from <paramref name="data"/>.
+        /// Must be within the <paramref name="data"/> array bounds.</param>
+        /// <param name="elementCount">Number of elements to copy from <paramref name="data"/>.
+        /// The combination of <paramref name="startIndex"/> and <paramref name="elementCount"/> 
+        /// must be within the <paramref name="data"/> array bounds.</param>
+		public void SetData<T>(T[] data, int startIndex, int elementCount) where T : struct
+        {
+            var elementSizeInBytes = ReflectionHelpers.SizeOf<T>.Get();
+            SetDataInternal<T>(0, data, startIndex, elementCount, elementSizeInBytes, SetDataOptions.None);
+		}
+		
+        /// <summary>
+        /// Sets the vertex buffer data. This is the same as calling <see cref="SetData{T}(int, T[], int, int, int)"/> 
+        /// with <c>offsetInBytes</c> and <c>startIndex</c> equal to <c>0</c>, <c>elementCount</c> equal to <c>data.Length</c>, 
+        /// and <c>vertexStride</c> equal to <c>sizeof(T)</c>.
+        /// </summary>
+        /// <typeparam name="T">Type of elements in the data array.</typeparam>
+        /// <param name="data">Data array.</param>
+        public void SetData<T>(T[] data) where T : struct
+        {
+            var elementSizeInBytes = ReflectionHelpers.SizeOf<T>.Get();
+            SetDataInternal<T>(0, data, 0, data.Length, elementSizeInBytes, SetDataOptions.None);
+        }
+
+        protected void SetDataInternal<T>(int offsetInBytes, T[] data, int startIndex, int elementCount, int vertexStride, SetDataOptions options) where T : struct
+        {
+            if (data == null)
+                throw new ArgumentNullException("data");
+
+            var elementSizeInBytes = ReflectionHelpers.SizeOf<T>.Get();
+            var bufferSize = VertexCount * VertexDeclaration.VertexStride;
+
+            if (vertexStride == 0)
+                vertexStride = elementSizeInBytes;
+
+            var vertexByteSize = VertexCount * VertexDeclaration.VertexStride;
+            if (vertexStride > vertexByteSize)
+                throw new ArgumentOutOfRangeException("vertexStride", "Vertex stride can not be larger than the vertex buffer size.");
+
+            if (startIndex + elementCount > data.Length || elementCount <= 0)
+                throw new ArgumentOutOfRangeException("data","The array specified in the data parameter is not the correct size for the amount of data requested.");
+            if (elementCount > 1 && (elementCount * vertexStride > bufferSize))
+                throw new InvalidOperationException("The vertex stride is larger than the vertex buffer.");
+            if (vertexStride < elementSizeInBytes)
+                throw new ArgumentOutOfRangeException("The vertex stride must be greater than or equal to the size of the specified data (" + elementSizeInBytes + ").");            
+
+            PlatformSetDataInternal<T>(offsetInBytes, data, startIndex, elementCount, vertexStride, options, bufferSize, elementSizeInBytes);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexBufferBinding.cs b/MonoGame.Framework/Graphics/Vertices/VertexBufferBinding.cs
new file mode 100644
index 00000000000..f929724122f
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexBufferBinding.cs
@@ -0,0 +1,103 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines how a vertex buffer is bound to the graphics device for rendering.
+    /// </summary>
+    public struct VertexBufferBinding
+    {
+        private readonly VertexBuffer _vertexBuffer;
+        private readonly int _vertexOffset;
+        private readonly int _instanceFrequency;
+
+        /// <summary>
+        /// Gets the vertex buffer.
+        /// </summary>
+        /// <value>The vertex buffer.</value>
+        public VertexBuffer VertexBuffer
+        {
+            get { return _vertexBuffer; }
+        }
+
+        /// <summary>
+        /// Gets the index of the first vertex in the vertex buffer to use.
+        /// </summary>
+        /// <value>The index of the first vertex in the vertex buffer to use.</value>
+        public int VertexOffset
+        {
+            get { return _vertexOffset; }
+        }
+
+        /// <summary>
+        /// Gets the number of instances to draw using the same per-instance data before advancing
+        /// in the buffer by one element.
+        /// </summary>
+        /// <value>
+        /// The number of instances to draw using the same per-instance data before advancing in the
+        /// buffer by one element. This value must be 0 for an element that contains per-vertex
+        /// data and greater than 0 for per-instance data.
+        /// </value>
+        public int InstanceFrequency
+        {
+            get { return _instanceFrequency; }
+        }
+
+        /// <summary>
+        /// Creates an instance of <see cref="VertexBufferBinding"/>.
+        /// </summary>
+        /// <param name="vertexBuffer">The vertex buffer to bind.</param>
+        public VertexBufferBinding(VertexBuffer vertexBuffer)
+            : this(vertexBuffer, 0, 0)
+        {
+        }
+
+        /// <summary>
+        /// Creates an instance of <see cref="VertexBufferBinding"/>.
+        /// </summary>
+        /// <param name="vertexBuffer">The vertex buffer to bind.</param>
+        /// <param name="vertexOffset">
+        /// The index of the first vertex in the vertex buffer to use.
+        /// </param>
+        public VertexBufferBinding(VertexBuffer vertexBuffer, int vertexOffset)
+            : this(vertexBuffer, vertexOffset, 0)
+        {
+        }
+
+        /// <summary>
+        /// Creates an instance of VertexBufferBinding.
+        /// </summary>
+        /// <param name="vertexBuffer">The vertex buffer to bind.</param>
+        /// <param name="vertexOffset">
+        /// The index of the first vertex in the vertex buffer to use.
+        /// </param>
+        /// <param name="instanceFrequency">
+        /// The number of instances to draw using the same per-instance data before advancing in the
+        /// buffer by one element. This value must be 0 for an element that contains per-vertex data
+        /// and greater than 0 for per-instance data.
+        /// </param>
+        /// <exception cref="ArgumentNullException">
+        /// <paramref name="vertexBuffer"/> is <see langword="null"/>.
+        /// </exception>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// <paramref name="vertexOffset"/> or <paramref name="instanceFrequency"/> is invalid.
+        /// </exception>
+        public VertexBufferBinding(VertexBuffer vertexBuffer, int vertexOffset, int instanceFrequency)
+        {
+            if (vertexBuffer == null)
+                throw new ArgumentNullException("vertexBuffer");
+            if (vertexOffset < 0 || vertexOffset >= vertexBuffer.VertexCount)
+                throw new ArgumentOutOfRangeException("vertexOffset");
+            if (instanceFrequency < 0)
+                throw new ArgumentOutOfRangeException("instanceFrequency");
+
+            _vertexBuffer = vertexBuffer;
+            _vertexOffset = vertexOffset;
+            _instanceFrequency = instanceFrequency;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexBufferBindings.DirectX.cs b/MonoGame.Framework/Graphics/Vertices/VertexBufferBindings.DirectX.cs
new file mode 100644
index 00000000000..91de6490331
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexBufferBindings.DirectX.cs
@@ -0,0 +1,30 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    partial class VertexBufferBindings
+    {
+        /// <summary>
+        /// Creates an <see cref="ImmutableVertexInputLayout"/> that can be used as a key in the
+        /// <see cref="InputLayoutCache"/>.
+        /// </summary>
+        /// <returns>The <see cref="ImmutableVertexInputLayout"/>.</returns>
+        public ImmutableVertexInputLayout ToImmutable()
+        {
+            int count = Count;
+
+            var vertexDeclarations = new VertexDeclaration[count];
+            Array.Copy(VertexDeclarations, vertexDeclarations, count);
+
+            var instanceFrequencies = new int[count];
+            Array.Copy(InstanceFrequencies, instanceFrequencies, count);
+
+            return new ImmutableVertexInputLayout(vertexDeclarations, instanceFrequencies);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexBufferBindings.cs b/MonoGame.Framework/Graphics/Vertices/VertexBufferBindings.cs
new file mode 100644
index 00000000000..b33ce30aefc
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexBufferBindings.cs
@@ -0,0 +1,169 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Stores the vertex buffers to be bound to the input assembler stage.
+    /// </summary>
+    internal sealed partial class VertexBufferBindings : VertexInputLayout
+    {
+        private readonly VertexBuffer[] _vertexBuffers;
+        private readonly int[] _vertexOffsets;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VertexBufferBindings" /> class.
+        /// </summary>
+        /// <param name="maxVertexBufferSlots">The maximum number of vertex buffer slots.</param>
+        public VertexBufferBindings(int maxVertexBufferSlots)
+            : base(new VertexDeclaration[maxVertexBufferSlots], new int[maxVertexBufferSlots], 0)
+        {
+            _vertexBuffers = new VertexBuffer[maxVertexBufferSlots];
+            _vertexOffsets = new int[maxVertexBufferSlots];
+        }
+
+        /// <summary>
+        /// Clears the vertex buffer slots.
+        /// </summary>
+        /// <returns>
+        /// <see langword="true"/> if the input layout was changed; otherwise,
+        /// <see langword="false"/>.
+        /// </returns>
+        public bool Clear()
+        {
+            if (Count == 0)
+                return false;
+
+            Array.Clear(VertexDeclarations, 0, Count);
+            Array.Clear(InstanceFrequencies, 0, Count);
+            Array.Clear(_vertexBuffers, 0, Count);
+            Array.Clear(_vertexOffsets, 0, Count);
+            Count = 0;
+            return true;
+        }
+
+        /// <summary>
+        /// Binds the specified vertex buffer to the first input slot.
+        /// </summary>
+        /// <param name="vertexBuffer">The vertex buffer.</param>
+        /// <param name="vertexOffset">
+        /// The offset (in vertices) from the beginning of the vertex buffer to the first vertex to 
+        /// use.
+        /// </param>
+        /// <returns>
+        /// <see langword="true"/> if the input layout was changed; otherwise,
+        /// <see langword="false"/>.
+        /// </returns>
+        public bool Set(VertexBuffer vertexBuffer, int vertexOffset)
+        {
+            Debug.Assert(vertexBuffer != null);
+            Debug.Assert(0 <= vertexOffset && vertexOffset < vertexBuffer.VertexCount);
+
+            if (Count == 1
+                && InstanceFrequencies[0] == 0
+                && _vertexBuffers[0] == vertexBuffer
+                && _vertexOffsets[0] == vertexOffset)
+            {
+                return false;
+            }
+
+            VertexDeclarations[0] = vertexBuffer.VertexDeclaration;
+            InstanceFrequencies[0] = 0;
+            _vertexBuffers[0] = vertexBuffer;
+            _vertexOffsets[0] = vertexOffset;
+            if (Count > 1)
+            {
+                Array.Clear(VertexDeclarations, 1, Count - 1);
+                Array.Clear(InstanceFrequencies, 1, Count - 1);
+                Array.Clear(_vertexBuffers, 1, Count - 1);
+                Array.Clear(_vertexOffsets, 1, Count - 1);
+            }
+
+            Count = 1;
+            return true;
+        }
+
+        /// <summary>
+        /// Binds the the specified vertex buffers to the input slots.
+        /// </summary>
+        /// <param name="vertexBufferBindings">The vertex buffer bindings.</param>
+        /// <returns>
+        /// <see langword="true"/> if the input layout was changed; otherwise,
+        /// <see langword="false"/>.
+        /// </returns>
+        public bool Set(params VertexBufferBinding[] vertexBufferBindings)
+        {
+            Debug.Assert(vertexBufferBindings != null);
+            Debug.Assert(vertexBufferBindings.Length > 0);
+            Debug.Assert(vertexBufferBindings.Length <= _vertexBuffers.Length);
+
+            bool isDirty = false;
+            for (int i = 0; i < vertexBufferBindings.Length; i++)
+            {
+                Debug.Assert(vertexBufferBindings[i].VertexBuffer != null);
+
+                if (InstanceFrequencies[i] == vertexBufferBindings[i].InstanceFrequency
+                    && _vertexBuffers[i] == vertexBufferBindings[i].VertexBuffer
+                    && _vertexOffsets[i] == vertexBufferBindings[i].VertexOffset)
+                {
+                    continue;
+                }
+
+                VertexDeclarations[i] = vertexBufferBindings[i].VertexBuffer.VertexDeclaration;
+                InstanceFrequencies[i] = vertexBufferBindings[i].InstanceFrequency;
+                _vertexBuffers[i] = vertexBufferBindings[i].VertexBuffer;
+                _vertexOffsets[i] = vertexBufferBindings[i].VertexOffset;
+                isDirty = true;
+            }
+
+            if (Count > vertexBufferBindings.Length)
+            {
+                int startIndex = vertexBufferBindings.Length;
+                int length = Count - startIndex;
+                Array.Clear(VertexDeclarations, startIndex, length);
+                Array.Clear(InstanceFrequencies, startIndex, length);
+                Array.Clear(_vertexBuffers, startIndex, length);
+                Array.Clear(_vertexOffsets, startIndex, length);
+                isDirty = true;
+            }
+
+            Count = vertexBufferBindings.Length;
+            return isDirty;
+        }
+
+        /// <summary>
+        /// Gets vertex buffer bound to the specified input slots.
+        /// </summary>
+        /// <returns>The vertex buffer binding.</returns>
+        public VertexBufferBinding Get(int slot)
+        {
+            Debug.Assert(0 <= slot && slot < Count);
+
+            return new VertexBufferBinding(
+                _vertexBuffers[slot],
+                _vertexOffsets[slot],
+                InstanceFrequencies[slot]);
+        }
+
+        /// <summary>
+        /// Gets vertex buffers bound to the input slots.
+        /// </summary>
+        /// <returns>The vertex buffer bindings.</returns>
+        public VertexBufferBinding[] Get()
+        {
+            var bindings = new VertexBufferBinding[Count];
+            for (int i = 0; i < bindings.Length; i++)
+                bindings[i] = new VertexBufferBinding(
+                    _vertexBuffers[i],
+                    _vertexOffsets[i],
+                    InstanceFrequencies[i]);
+
+            return bindings;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexDeclaration.OpenGL.cs b/MonoGame.Framework/Graphics/Vertices/VertexDeclaration.OpenGL.cs
new file mode 100644
index 00000000000..6bfbceefb13
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexDeclaration.OpenGL.cs
@@ -0,0 +1,95 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using MonoGame.OpenGL;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class VertexDeclaration
+    {
+        private readonly Dictionary<int, VertexDeclarationAttributeInfo> _shaderAttributeInfo = new Dictionary<int, VertexDeclarationAttributeInfo>();
+
+        internal VertexDeclarationAttributeInfo GetAttributeInfo(Shader shader, int programHash)
+        {
+            VertexDeclarationAttributeInfo attrInfo;
+            if (_shaderAttributeInfo.TryGetValue(programHash, out attrInfo))
+                return attrInfo;
+
+            // Get the vertex attribute info and cache it
+            attrInfo = new VertexDeclarationAttributeInfo(GraphicsDevice.MaxVertexAttributes);
+
+            foreach (var ve in InternalVertexElements)
+            {
+                var attributeLocation = shader.GetAttribLocation(ve.VertexElementUsage, ve.UsageIndex);
+                // XNA appears to ignore usages it can't find a match for, so we will do the same
+                if (attributeLocation < 0)
+                    continue;
+
+                attrInfo.Elements.Add(new VertexDeclarationAttributeInfo.Element
+                {
+                    Offset = ve.Offset,
+                    AttributeLocation = attributeLocation,
+                    NumberOfElements = ve.VertexElementFormat.OpenGLNumberOfElements(),
+                    VertexAttribPointerType = ve.VertexElementFormat.OpenGLVertexAttribPointerType(),
+                    Normalized = ve.OpenGLVertexAttribNormalized(),
+                });
+                attrInfo.EnabledAttributes[attributeLocation] = true;
+            }
+
+            _shaderAttributeInfo.Add(programHash, attrInfo);
+            return attrInfo;
+        }
+
+
+		internal void Apply(Shader shader, IntPtr offset, int programHash)
+		{
+            var attrInfo = GetAttributeInfo(shader, programHash);
+
+            // Apply the vertex attribute info
+            foreach (var element in attrInfo.Elements)
+            {
+                GL.VertexAttribPointer(element.AttributeLocation,
+                    element.NumberOfElements,
+                    element.VertexAttribPointerType,
+                    element.Normalized,
+                    VertexStride,
+                    (IntPtr)(offset.ToInt64() + element.Offset));
+#if !(GLES || MONOMAC)
+                if (GraphicsDevice.GraphicsCapabilities.SupportsInstancing)
+                    GL.VertexAttribDivisor(element.AttributeLocation, 0);
+#endif
+                GraphicsExtensions.CheckGLError();
+            }
+            GraphicsDevice.SetVertexAttributeArray(attrInfo.EnabledAttributes);
+		    GraphicsDevice._attribsDirty = true;
+		}
+
+        /// <summary>
+        /// Vertex attribute information for a particular shader/vertex declaration combination.
+        /// </summary>
+        internal class VertexDeclarationAttributeInfo
+        {
+            internal bool[] EnabledAttributes;
+
+            internal class Element
+            {
+                public int Offset;
+                public int AttributeLocation;
+                public int NumberOfElements;
+                public VertexAttribPointerType VertexAttribPointerType;
+                public bool Normalized;
+            }
+
+            internal List<Element> Elements;
+
+            internal VertexDeclarationAttributeInfo(int maxVertexAttributes)
+            {
+                EnabledAttributes = new bool[maxVertexAttributes];
+                Elements = new List<Element>();
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexDeclaration.Web.cs b/MonoGame.Framework/Graphics/Vertices/VertexDeclaration.Web.cs
new file mode 100644
index 00000000000..917e672eb12
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexDeclaration.Web.cs
@@ -0,0 +1,16 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    public partial class VertexDeclaration
+    {
+		internal void Apply(Shader shader, IntPtr offset)
+		{
+            throw new NotImplementedException();
+		}
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexDeclaration.cs b/MonoGame.Framework/Graphics/Vertices/VertexDeclaration.cs
new file mode 100644
index 00000000000..069621c2c63
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexDeclaration.cs
@@ -0,0 +1,316 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines per-vertex data of a vertex buffer.
+    /// </summary>
+    /// <remarks>
+    /// <see cref="VertexDeclaration"/> implements <see cref="IEquatable{T}"/> and can be used as
+    /// a key in a dictionary. Two vertex declarations are considered equal if the vertices are
+    /// structurally equivalent, i.e. the vertex elements and the vertex stride are identical. (The
+    /// properties <see cref="GraphicsResource.Name"/> and <see cref="GraphicsResource.Tag"/> are
+    /// ignored in <see cref="GetHashCode"/> and <see cref="Equals(VertexDeclaration)"/>!)
+    /// </remarks>
+    public partial class VertexDeclaration : GraphicsResource, IEquatable<VertexDeclaration>
+    {
+        // Note for future refactoring:
+        // For XNA-compatibility VertexDeclaration is derived from GraphicsResource, which means it
+        // has GraphicsDevice, Name, Tag and implements IDisposable. This is unnecessary in
+        // MonoGame. VertexDeclaration.GraphicsDevice is never set.
+        // --> VertexDeclaration should be a lightweight immutable type. No base class, no IDisposable.
+        //     (Use the internal type Data. Do not expose a constructor. Use a factory method to
+        //     cache the vertex declarations.)
+
+        #region ----- Data shared between structurally identical vertex declarations -----
+
+        private sealed class Data : IEquatable<Data>
+        {
+            private readonly int _hashCode;
+            public readonly int VertexStride;
+            public VertexElement[] Elements;
+
+            public Data(int vertexStride, VertexElement[] elements)
+            {
+                VertexStride = vertexStride;
+                Elements = elements;
+
+                // Pre-calculate hash code for fast comparisons and lookup in dictionaries.
+                unchecked
+                {
+                    _hashCode = elements[0].GetHashCode();
+                    for (int i = 1; i < elements.Length; i++)
+                        _hashCode = (_hashCode * 397) ^ elements[i].GetHashCode();
+
+                    _hashCode = (_hashCode * 397) ^ elements.Length;
+                    _hashCode = (_hashCode * 397) ^ vertexStride;
+                }
+            }
+
+            public override bool Equals(object obj)
+            {
+                return Equals(obj as Data);
+            }
+
+            public bool Equals(Data other)
+            {
+                if (ReferenceEquals(null, other))
+                    return false;
+                if (ReferenceEquals(this, other))
+                    return true;
+
+                if (_hashCode != other._hashCode
+                    || VertexStride != other.VertexStride
+                    || Elements.Length != other.Elements.Length)
+                {
+                    return false;
+                }
+
+                for (int i = 0; i < Elements.Length; i++)
+                    if (!Elements[i].Equals(other.Elements[i]))
+                        return false;
+
+                return true;
+            }
+
+            public override int GetHashCode()
+            {
+                return _hashCode;
+            }
+        }
+        #endregion
+
+
+        #region ----- VertexDeclaration Cache -----
+
+        private static readonly Dictionary<Data, VertexDeclaration> _vertexDeclarationCache;
+
+        static VertexDeclaration()
+        {
+            _vertexDeclarationCache = new Dictionary<Data, VertexDeclaration>();
+        }
+
+        internal static VertexDeclaration GetOrCreate(int vertexStride, VertexElement[] elements)
+        {
+            lock (_vertexDeclarationCache)
+            {
+                var data = new Data(vertexStride, elements);
+                VertexDeclaration vertexDeclaration;
+                if (!_vertexDeclarationCache.TryGetValue(data, out vertexDeclaration))
+                {
+                    // Data.Elements have already been set in the Data ctor. However, entries
+                    // in the vertex declaration cache must be immutable. Therefore, we create a 
+                    // copy of the array, which the user cannot access.
+                    data.Elements = (VertexElement[])elements.Clone();
+
+                    vertexDeclaration = new VertexDeclaration(data);
+                    _vertexDeclarationCache[data] = vertexDeclaration;
+                }
+
+                return vertexDeclaration;
+            }
+        }
+
+        private VertexDeclaration(Data data)
+        {
+            _data = data;
+        }
+        #endregion
+
+
+        private readonly Data _data;
+
+        /// <summary>
+        /// Gets the internal vertex elements array.
+        /// </summary>
+        /// <value>The internal vertex elements array.</value>
+        internal VertexElement[] InternalVertexElements
+        {
+            get { return _data.Elements; }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VertexDeclaration"/> class.
+        /// </summary>
+        /// <param name="elements">The vertex elements.</param>
+        /// <exception cref="ArgumentNullException">
+        /// <paramref name="elements"/> is <see langword="null"/> or empty.
+        /// </exception>
+        public VertexDeclaration(params VertexElement[] elements)
+            : this(GetVertexStride(elements), elements)
+		{
+		}
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VertexDeclaration"/> class.
+        /// </summary>
+        /// <param name="vertexStride">The size of a vertex (including padding) in bytes.</param>
+        /// <param name="elements">The vertex elements.</param>
+        /// <exception cref="ArgumentNullException">
+        /// <paramref name="elements"/> is <see langword="null"/> or empty.
+        /// </exception>
+        public VertexDeclaration(int vertexStride, params VertexElement[] elements)
+        {
+            if ((elements == null) || (elements.Length == 0))
+                throw new ArgumentNullException("elements", "Elements cannot be empty");
+
+            lock (_vertexDeclarationCache)
+            {
+                var data = new Data(vertexStride, elements);
+                VertexDeclaration vertexDeclaration;
+                if (_vertexDeclarationCache.TryGetValue(data, out vertexDeclaration))
+                {
+                    // Reuse existing data.
+                    _data = vertexDeclaration._data;
+                }
+                else
+                {
+                    // Cache new vertex declaration.
+                    data.Elements = (VertexElement[])elements.Clone();
+                    _data = data;
+                    _vertexDeclarationCache[data] = this;
+                }
+            }
+        }
+
+        private static int GetVertexStride(VertexElement[] elements)
+		{
+			int max = 0;
+			for (var i = 0; i < elements.Length; i++)
+			{
+                var start = elements[i].Offset + elements[i].VertexElementFormat.GetSize();
+				if (max < start)
+					max = start;
+			}
+
+			return max;
+		}
+
+        /// <summary>
+        /// Returns the VertexDeclaration for Type.
+        /// </summary>
+        /// <param name="vertexType">A value type which implements the IVertexType interface.</param>
+        /// <returns>The VertexDeclaration.</returns>
+        /// <remarks>
+        /// Prefer to use VertexDeclarationCache when the declaration lookup
+        /// can be performed with a templated type.
+        /// </remarks>
+		internal static VertexDeclaration FromType(Type vertexType)
+		{
+			if (vertexType == null)
+				throw new ArgumentNullException("vertexType", "Cannot be null");
+
+            if (!ReflectionHelpers.IsValueType(vertexType))
+            {
+				throw new ArgumentException("Must be value type", "vertexType");
+			}
+
+            var type = Activator.CreateInstance(vertexType) as IVertexType;
+			if (type == null)
+			{
+				throw new ArgumentException("vertexData does not inherit IVertexType");
+			}
+
+            var vertexDeclaration = type.VertexDeclaration;
+			if (vertexDeclaration == null)
+			{
+				throw new Exception("VertexDeclaration cannot be null");
+			}
+
+			return vertexDeclaration;
+		}
+
+        /// <summary>
+        /// Gets a copy of the vertex elements.
+        /// </summary>
+        /// <returns>A copy of the vertex elements.</returns>
+        public VertexElement[] GetVertexElements()
+		{
+			return (VertexElement[])_data.Elements.Clone();
+		}
+
+        /// <summary>
+        /// Gets the size of a vertex (including padding) in bytes.
+        /// </summary>
+        /// <value>The size of a vertex (including padding) in bytes.</value>
+        public int VertexStride
+		{
+			get { return _data.VertexStride; }
+		}
+
+        /// <summary>
+        /// Determines whether the specified <see cref="object"/> is equal to this instance.
+        /// </summary>
+        /// <param name="obj">The object to compare with the current object.</param>
+        /// <returns>
+        /// <see langword="true"/> if the specified <see cref="object"/> is equal to this instance;
+        /// otherwise, <see langword="false"/>.
+        /// </returns>
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as VertexDeclaration);
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="VertexDeclaration"/> is equal to this
+        /// instance.
+        /// </summary>
+        /// <param name="other">The object to compare with the current object.</param>
+        /// <returns>
+        /// <see langword="true"/> if the specified <see cref="VertexDeclaration"/> is equal to this
+        /// instance; otherwise, <see langword="false"/>.
+        /// </returns>
+        public bool Equals(VertexDeclaration other)
+        {
+            return other != null && ReferenceEquals(_data, other._data);
+        }
+
+        /// <summary>
+        /// Returns a hash code for this instance.
+        /// </summary>
+        /// <returns>
+        /// A hash code for this instance, suitable for use in hashing algorithms and data
+        /// structures like a hash table.
+        /// </returns>
+        public override int GetHashCode()
+        {
+            return _data.GetHashCode();
+        }
+
+        /// <summary>
+        /// Compares two <see cref="VertexElement"/> instances to determine whether they are the
+        /// same.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>
+        /// <see langword="true"/> if the <paramref name="left"/> and <paramref name="right"/> are
+        /// the same; otherwise, <see langword="false"/>.
+        /// </returns>
+        public static bool operator ==(VertexDeclaration left, VertexDeclaration right)
+        {
+            return Equals(left, right);
+        }
+
+        /// <summary>
+        /// Compares two <see cref="VertexElement"/> instances to determine whether they are
+        /// different.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>
+        /// <see langword="true"/> if the <paramref name="left"/> and <paramref name="right"/> are
+        /// the different; otherwise, <see langword="false"/>.
+        /// </returns>
+        public static bool operator !=(VertexDeclaration left, VertexDeclaration right)
+        {
+            return !Equals(left, right);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexDeclarationCache.cs b/MonoGame.Framework/Graphics/Vertices/VertexDeclarationCache.cs
new file mode 100644
index 00000000000..6b2fa529af2
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexDeclarationCache.cs
@@ -0,0 +1,24 @@
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Helper class which ensures we only lookup a vertex 
+    /// declaration for a particular type once.
+    /// </summary>
+    /// <typeparam name="T">A vertex structure which implements IVertexType.</typeparam>
+    internal class VertexDeclarationCache<T>
+        where T : struct, IVertexType
+    {
+        static private VertexDeclaration _cached;
+
+        static public VertexDeclaration VertexDeclaration
+        {
+            get
+            {
+                if (_cached == null)
+                    _cached = VertexDeclaration.FromType(typeof(T));
+
+                return _cached;
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexElement.DirectX.cs b/MonoGame.Framework/Graphics/Vertices/VertexElement.DirectX.cs
new file mode 100644
index 00000000000..fd1b9cfca40
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexElement.DirectX.cs
@@ -0,0 +1,117 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    partial struct VertexElement
+    {
+        /// <summary>
+        /// Gets the DirectX <see cref="SharpDX.Direct3D11.InputElement"/>.
+        /// </summary>
+        /// <param name="slot">The input resource slot.</param>
+        /// <param name="instanceFrequency">
+        /// The number of instances to draw using the same per-instance data before advancing in the
+        /// buffer by one element. This value must be 0 for an element that contains per-vertex
+        /// data.
+        /// </param>
+        /// <returns><see cref="SharpDX.Direct3D11.InputElement"/>.</returns>
+        /// <exception cref="NotSupportedException">
+        /// Unknown vertex element format or usage!
+        /// </exception>
+        internal SharpDX.Direct3D11.InputElement GetInputElement(int slot, int instanceFrequency)
+        {
+            var element = new SharpDX.Direct3D11.InputElement();
+
+            switch (_usage)
+            {
+                case VertexElementUsage.Position:
+                    element.SemanticName = "POSITION";
+                    break;
+                case VertexElementUsage.Color:
+                    element.SemanticName = "COLOR";
+                    break;
+                case VertexElementUsage.Normal:
+                    element.SemanticName = "NORMAL";
+                    break;
+                case VertexElementUsage.TextureCoordinate:
+                    element.SemanticName = "TEXCOORD";
+                    break;
+                case VertexElementUsage.BlendIndices:
+                    element.SemanticName = "BLENDINDICES";
+                    break;
+                case VertexElementUsage.BlendWeight:
+                    element.SemanticName = "BLENDWEIGHT";
+                    break;
+                case VertexElementUsage.Binormal:
+                    element.SemanticName = "BINORMAL";
+                    break;
+                case VertexElementUsage.Tangent:
+                    element.SemanticName = "TANGENT";
+                    break;
+                case VertexElementUsage.PointSize:
+                    element.SemanticName = "PSIZE";
+                    break;
+                default:
+                    throw new NotSupportedException("Unknown vertex element usage!");
+            }
+
+            element.SemanticIndex = _usageIndex;
+
+            switch (_format)
+            {
+                case VertexElementFormat.Single:
+                    element.Format = SharpDX.DXGI.Format.R32_Float;
+                    break;
+                case VertexElementFormat.Vector2:
+                    element.Format = SharpDX.DXGI.Format.R32G32_Float;
+                    break;
+                case VertexElementFormat.Vector3:
+                    element.Format = SharpDX.DXGI.Format.R32G32B32_Float;
+                    break;
+                case VertexElementFormat.Vector4:
+                    element.Format = SharpDX.DXGI.Format.R32G32B32A32_Float;
+                    break;
+                case VertexElementFormat.Color:
+                    element.Format = SharpDX.DXGI.Format.R8G8B8A8_UNorm;
+                    break;
+                case VertexElementFormat.Byte4:
+                    element.Format = SharpDX.DXGI.Format.R8G8B8A8_UInt;
+                    break;
+                case VertexElementFormat.Short2:
+                    element.Format =  SharpDX.DXGI.Format.R16G16_SInt;
+                    break;
+                case VertexElementFormat.Short4:
+                    element.Format =  SharpDX.DXGI.Format.R16G16B16A16_SInt;
+                    break;
+                case VertexElementFormat.NormalizedShort2:
+                    element.Format =  SharpDX.DXGI.Format.R16G16_SNorm;
+                    break;
+                case VertexElementFormat.NormalizedShort4:
+                    element.Format =  SharpDX.DXGI.Format.R16G16B16A16_SNorm;
+                    break;
+                case VertexElementFormat.HalfVector2:
+                    element.Format =  SharpDX.DXGI.Format.R16G16_Float;
+                    break;
+                case VertexElementFormat.HalfVector4:
+                    element.Format =  SharpDX.DXGI.Format.R16G16B16A16_Float;
+                    break;                
+                default:
+                    throw new NotSupportedException("Unknown vertex element format!");
+            }
+
+            element.Slot = slot;
+            element.AlignedByteOffset = _offset;
+            
+            // Note that instancing is only supported in feature level 9.3 and above.
+            element.Classification = (instanceFrequency == 0) 
+                                     ? SharpDX.Direct3D11.InputClassification.PerVertexData
+                                     : SharpDX.Direct3D11.InputClassification.PerInstanceData;
+            element.InstanceDataStepRate = instanceFrequency;
+
+            return element;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexElement.cs b/MonoGame.Framework/Graphics/Vertices/VertexElement.cs
new file mode 100644
index 00000000000..94a25977c66
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexElement.cs
@@ -0,0 +1,179 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines a single element in a vertex.
+    /// </summary>
+    public partial struct VertexElement : IEquatable<VertexElement>
+    {
+        private int _offset;
+        private VertexElementFormat _format;
+        private VertexElementUsage _usage;
+        private int _usageIndex;
+
+        /// <summary>
+        /// Gets or sets the offset in bytes from the beginning of the stream to the vertex element.
+        /// </summary>
+        /// <value>The offset in bytes.</value>
+        public int Offset
+        {
+            get { return _offset; }
+            set { _offset = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the data format.
+        /// </summary>
+        /// <value>The data format.</value>
+        public VertexElementFormat VertexElementFormat
+        {
+            get { return _format; }
+            set { _format = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the HLSL semantic of the element in the vertex shader input.
+        /// </summary>
+        /// <value>The HLSL semantic of the element in the vertex shader input.</value>
+        public VertexElementUsage VertexElementUsage
+        {
+            get { return _usage; }
+            set { _usage = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the semantic index.
+        /// </summary>
+        /// <value>
+        /// The semantic index, which is required if the semantic is used for more than one vertex
+        /// element.
+        /// </value>
+        /// <remarks>
+        /// Usage indices in a vertex declaration usually start with 0. When multiple vertex buffers
+        /// are bound to the input assembler stage (see <see cref="GraphicsDevice.SetVertexBuffers"/>),
+        /// MonoGame internally adjusts the usage indices based on the order in which the vertex
+        /// buffers are bound.
+        /// </remarks>
+        public int UsageIndex
+        {
+            get { return _usageIndex; }
+            set { _usageIndex = value; }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VertexElement"/> struct.
+        /// </summary>
+        /// <param name="offset">The offset in bytes from the beginning of the stream to the vertex element.</param>
+        /// <param name="elementFormat">The element format.</param>
+        /// <param name="elementUsage">The HLSL semantic of the element in the vertex shader input-signature.</param>
+        /// <param name="usageIndex">The semantic index, which is required if the semantic is used for more than one vertex element.</param>
+        public VertexElement(int offset, VertexElementFormat elementFormat, VertexElementUsage elementUsage, int usageIndex)
+        {
+            _offset = offset;
+            _format = elementFormat;
+            _usageIndex = usageIndex;
+            _usage = elementUsage;
+        }
+
+        /// <summary>
+        /// Returns a hash code for this instance.
+        /// </summary>
+        /// <returns>
+        /// A hash code for this instance, suitable for use in hashing algorithms and data
+        /// structures like a hash table.
+        /// </returns>
+        public override int GetHashCode()
+        {
+            // ReSharper disable NonReadonlyMemberInGetHashCode
+
+            // Optimized hash:
+            // - DirectX 11 has max 32 registers. A register is max 16 byte. _offset is in the range
+            //   0 to 512 (exclusive). --> _offset needs 9 bit.
+            // - VertexElementFormat has 12 values. --> _format needs 4 bit.
+            // - VertexElementUsage has 13 values. --> _usage needs 4 bit.
+            // - DirectX 11 has max 32 registers. --> _usageIndex needs 6 bit.
+            // (Note: If these assumptions are correct we get a unique hash code. If these 
+            // assumptions are not correct, we still get a useful hash code because we use XOR.)
+            int hashCode = _offset;
+            hashCode ^= (int)_format << 9;
+            hashCode ^= (int)_usage << (9 + 4);
+            hashCode ^= _usageIndex << (9 + 4 + 4);
+            return hashCode;
+            // ReSharper restore NonReadonlyMemberInGetHashCode
+        }
+
+        /// <summary>
+        /// Returns a <see cref="string" /> that represents this instance.
+        /// </summary>
+        /// <returns>A <see cref="string" /> that represents this instance.</returns>
+        public override string ToString()
+        {
+            return "{Offset:" + _offset + " Format:" + _format + " Usage:" + _usage + " UsageIndex: " + _usageIndex + "}";
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="object"/> is equal to this instance.
+        /// </summary>
+        /// <param name="obj">The object to compare with the current object.</param>
+        /// <returns>
+        /// <see langword="true"/> if the specified <see cref="object"/> is equal to this instance;
+        /// otherwise, <see langword="false"/>.
+        /// </returns>
+        public override bool Equals(object obj)
+        {
+            return obj is VertexElement && Equals((VertexElement)obj);
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="VertexElement"/> is equal to this
+        /// instance.
+        /// </summary>
+        /// <param name="other">The object to compare with the current object.</param>
+        /// <returns>
+        /// <see langword="true"/> if the specified <see cref="VertexElement"/> is equal to this
+        /// instance; otherwise, <see langword="false"/>.
+        /// </returns>
+        public bool Equals(VertexElement other)
+        {
+            return _offset == other._offset
+                   && _format == other._format
+                   && _usage == other._usage
+                   && _usageIndex == other._usageIndex;
+        }
+
+        /// <summary>
+        /// Compares two <see cref="VertexElement"/> instances to determine whether they are the
+        /// same.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>
+        /// <see langword="true"/> if the <paramref name="left"/> and <paramref name="right"/> are
+        /// the same; otherwise, <see langword="false"/>.
+        /// </returns>
+        public static bool operator ==(VertexElement left, VertexElement right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        /// Compares two <see cref="VertexElement"/> instances to determine whether they are
+        /// different.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>
+        /// <see langword="true"/> if the <paramref name="left"/> and <paramref name="right"/> are
+        /// the different; otherwise, <see langword="false"/>.
+        /// </returns>
+        public static bool operator !=(VertexElement left, VertexElement right)
+        {
+            return !left.Equals(right);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexElementFormat.cs b/MonoGame.Framework/Graphics/Vertices/VertexElementFormat.cs
new file mode 100644
index 00000000000..47b8dbb24b2
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexElementFormat.cs
@@ -0,0 +1,61 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines vertex element formats.
+    /// </summary>
+    public enum VertexElementFormat
+    {
+        /// <summary>
+        /// Single 32-bit floating point number.
+        /// </summary>
+        Single,
+        /// <summary>
+        /// Two component 32-bit floating point number.
+        /// </summary>
+        Vector2,
+        /// <summary>
+        /// Three component 32-bit floating point number.
+        /// </summary>
+        Vector3, 
+        /// <summary>
+        /// Four component 32-bit floating point number.
+        /// </summary>
+        Vector4, 
+        /// <summary>
+        /// Four component, packed unsigned byte, mapped to 0 to 1 range. 
+        /// </summary>
+        Color,   
+        /// <summary>
+        /// Four component unsigned byte.
+        /// </summary>
+        Byte4,        
+        /// <summary>
+        /// Two component signed 16-bit integer.
+        /// </summary>
+        Short2,
+        /// <summary>
+        /// Four component signed 16-bit integer.
+        /// </summary>
+        Short4,
+        /// <summary>
+        /// Normalized, two component signed 16-bit integer.
+        /// </summary>
+        NormalizedShort2,
+        /// <summary>
+        /// Normalized, four component signed 16-bit integer.
+        /// </summary>
+        NormalizedShort4,
+        /// <summary>
+        /// Two component 16-bit floating point number.
+        /// </summary>
+        HalfVector2,  
+        /// <summary>
+        /// Four component 16-bit floating point number.
+        /// </summary>
+        HalfVector4
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexElementUsage.cs b/MonoGame.Framework/Graphics/Vertices/VertexElementUsage.cs
new file mode 100644
index 00000000000..0daebb15092
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexElementUsage.cs
@@ -0,0 +1,65 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Defines usage for vertex elements.
+    /// </summary>
+    public enum VertexElementUsage
+    {
+        /// <summary>
+        /// Position data.
+        /// </summary>
+        Position,
+        /// <summary>
+        /// Color data.
+        /// </summary>
+        Color,   
+        /// <summary>
+        /// Texture coordinate data or can be used for user-defined data.
+        /// </summary>
+        TextureCoordinate, 
+        /// <summary>
+        /// Normal data.
+        /// </summary>
+        Normal,
+        /// <summary>
+        /// Binormal data.
+        /// </summary>
+        Binormal,
+        /// <summary>
+        /// Tangent data.
+        /// </summary>
+        Tangent,
+        /// <summary>
+        /// Blending indices data.
+        /// </summary>
+        BlendIndices,
+        /// <summary>
+        /// Blending weight data.
+        /// </summary>
+        BlendWeight,     
+        /// <summary>
+        /// Depth data.
+        /// </summary>
+        Depth,
+        /// <summary>
+        /// Fog data.
+        /// </summary>
+        Fog,      
+        /// <summary>
+        /// Point size data. Usable for drawing point sprites.
+        /// </summary>
+        PointSize,
+        /// <summary>
+        /// Sampler data for specifies the displacement value to look up.
+        /// </summary>
+        Sample,     
+        /// <summary>
+        /// Single, positive float value, specifies a tessellation factor used in the tessellation unit to control the rate of tessellation.
+        /// </summary>
+        TessellateFactor
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexInputLayout.DirectX.cs b/MonoGame.Framework/Graphics/Vertices/VertexInputLayout.DirectX.cs
new file mode 100644
index 00000000000..74f849b69cb
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexInputLayout.DirectX.cs
@@ -0,0 +1,48 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Collections.Generic;
+using SharpDX.Direct3D11;
+
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    partial class VertexInputLayout
+    {
+        public InputElement[] GetInputElements()
+        {
+            var list = new List<InputElement>();
+            for (int i = 0; i < Count; i++)
+            {
+                foreach (var vertexElement in VertexDeclarations[i].InternalVertexElements)
+                {
+                    var inputElement = vertexElement.GetInputElement(i, InstanceFrequencies[i]);
+                    list.Add(inputElement);
+                }
+            }
+
+            var inputElements = list.ToArray();
+
+            // Fix semantics indices. (If there are more vertex declarations with, for example, 
+            // POSITION0, the indices are changed to POSITION1/2/3/...)
+            for (int i = 1; i < inputElements.Length; i++)
+            {
+                string semanticName = inputElements[i].SemanticName;
+                int semanticIndex = inputElements[i].SemanticIndex;
+                for (int j = 0; j < i; j++)
+                {
+                    if (inputElements[j].SemanticName == semanticName && inputElements[j].SemanticIndex == semanticIndex)
+                    {
+                        // Semantic index already used.
+                        semanticIndex++;
+                    }
+                }
+
+                inputElements[i].SemanticIndex = semanticIndex;
+            }
+
+            return inputElements;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexInputLayout.cs b/MonoGame.Framework/Graphics/Vertices/VertexInputLayout.cs
new file mode 100644
index 00000000000..3a63c81166b
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexInputLayout.cs
@@ -0,0 +1,165 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Stores the vertex layout (input elements) for the input assembler stage.
+    /// </summary>
+    /// <remarks>
+    /// In the DirectX version the input layouts are cached in a dictionary. The
+    /// <see cref="VertexInputLayout"/> is used as the key in the dictionary and therefore needs to
+    /// implement <see cref="IEquatable{T}"/>. Two <see cref="VertexInputLayout"/> instance are
+    /// considered equal if the vertex layouts are structurally identical.
+    /// </remarks>
+    internal abstract partial class VertexInputLayout : IEquatable<VertexInputLayout>
+    {
+        protected VertexDeclaration[] VertexDeclarations { get; private set; }
+        protected int[] InstanceFrequencies { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the number of used input slots.
+        /// </summary>
+        /// <value>The number of used input slots.</value>
+        public int Count { get; protected set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VertexInputLayout"/> class.
+        /// </summary>
+        /// <param name="maxVertexBufferSlots">The maximum number of vertex buffer slots.</param>
+        protected VertexInputLayout(int maxVertexBufferSlots)
+            : this(new VertexDeclaration[maxVertexBufferSlots], new int[maxVertexBufferSlots], 0)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VertexInputLayout"/> class.
+        /// </summary>
+        /// <param name="vertexDeclarations">The array for storing vertex declarations.</param>
+        /// <param name="instanceFrequencies">The array for storing instance frequencies.</param>
+        /// <param name="count">The number of used slots.</param>
+        protected VertexInputLayout(VertexDeclaration[] vertexDeclarations, int[] instanceFrequencies, int count)
+        {
+            Debug.Assert(vertexDeclarations != null);
+            Debug.Assert(instanceFrequencies != null);
+            Debug.Assert(count >= 0);
+            Debug.Assert(vertexDeclarations.Length >= count);
+            Debug.Assert(vertexDeclarations.Length == instanceFrequencies.Length);
+
+            Count = count;
+            VertexDeclarations = vertexDeclarations;
+            InstanceFrequencies = instanceFrequencies;
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="object"/> is equal to this instance.
+        /// </summary>
+        /// <param name="obj">The object to compare with the current object.</param>
+        /// <returns>
+        /// <see langword="true"/> if the specified <see cref="object"/> is equal to this instance;
+        /// otherwise, <see langword="false"/>.
+        /// </returns>
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as VertexInputLayout);
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="VertexInputLayout"/> is equal to this
+        /// instance.
+        /// </summary>
+        /// <param name="other">The object to compare with the current object.</param>
+        /// <returns>
+        /// <see langword="true"/> if the specified <see cref="VertexInputLayout"/> is equal to this
+        /// instance; otherwise, <see langword="false"/>.
+        /// </returns>
+        public bool Equals(VertexInputLayout other)
+        {
+            if (ReferenceEquals(null, other))
+                return false;
+            if (ReferenceEquals(this, other))
+                return true;
+
+            if (Count != other.Count)
+                return false;
+
+            for (int i = 0; i < Count; i++)
+            {
+                Debug.Assert(VertexDeclarations[i] != null);
+                if (!VertexDeclarations[i].Equals(other.VertexDeclarations[i]))
+                    return false;
+            }
+
+            for (int i = 0; i < Count; i++)
+            {
+                if (!InstanceFrequencies[i].Equals(other.InstanceFrequencies[i]))
+                    return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a hash code for this instance.
+        /// </summary>
+        /// <returns>
+        /// A hash code for this instance, suitable for use in hashing algorithms and data
+        /// structures like a hash table.
+        /// </returns>
+        public override int GetHashCode()
+        {
+            // ReSharper disable NonReadonlyMemberInGetHashCode
+            unchecked
+            {
+                int hashCode = 0;
+                if (Count > 0)
+                {
+                    hashCode = VertexDeclarations[0].GetHashCode();
+                    hashCode = (hashCode * 397) ^ InstanceFrequencies[0];
+                    for (int i = 1; i < Count; i++)
+                    {
+                        hashCode = (hashCode * 397) ^ VertexDeclarations[i].GetHashCode();
+                        hashCode = (hashCode * 397) ^ InstanceFrequencies[i];
+                    }
+                }
+                return hashCode;
+            }
+            // ReSharper restore NonReadonlyMemberInGetHashCode
+        }
+
+        /// <summary>
+        /// Compares two <see cref="VertexInputLayout"/> instances to determine whether they are the
+        /// same.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>
+        /// <see langword="true"/> if the <paramref name="left"/> and <paramref name="right"/> are
+        /// the same; otherwise, <see langword="false"/>.
+        /// </returns>
+        public static bool operator ==(VertexInputLayout left, VertexInputLayout right)
+        {
+            return Equals(left, right);
+        }
+
+        /// <summary>
+        /// Compares two <see cref="VertexInputLayout"/> instances to determine whether they are
+        /// different.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>
+        /// <see langword="true"/> if the <paramref name="left"/> and <paramref name="right"/> are
+        /// the different; otherwise, <see langword="false"/>.
+        /// </returns>
+        public static bool operator !=(VertexInputLayout left, VertexInputLayout right)
+        {
+            return !Equals(left, right);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexPosition.cs b/MonoGame.Framework/Graphics/Vertices/VertexPosition.cs
new file mode 100644
index 00000000000..d3ad73c18e3
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexPosition.cs
@@ -0,0 +1,69 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Runtime.Serialization;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    [DataContract]
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+	public struct VertexPosition : IVertexType
+	{
+        [DataMember]
+		public Vector3 Position;
+
+		public static readonly VertexDeclaration VertexDeclaration;
+
+		public VertexPosition(Vector3 position)
+		{
+			Position = position;
+		}
+
+		VertexDeclaration IVertexType.VertexDeclaration
+        {
+			get { return VertexDeclaration; }
+		}
+
+	    public override int GetHashCode()
+	    {
+	        return Position.GetHashCode();
+	    }
+
+		public override string ToString()
+		{
+            return "{{Position:" + Position + "}}";
+		}
+
+		public static bool operator == (VertexPosition left, VertexPosition right)
+		{
+			return left.Position == right.Position;
+		}
+
+		public static bool operator != (VertexPosition left, VertexPosition right)
+		{
+			return !(left == right);
+		}
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+            if (obj.GetType() != GetType())
+            {
+                return false;
+            }
+            return this == (VertexPosition) obj;
+        }
+
+        static VertexPosition()
+		{
+			VertexElement[] elements = { new VertexElement (0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0) };
+            VertexDeclaration declaration = new VertexDeclaration(elements);
+			VertexDeclaration = declaration;
+		}
+	}
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexPositionColor.cs b/MonoGame.Framework/Graphics/Vertices/VertexPositionColor.cs
new file mode 100644
index 00000000000..7dfe2eee577
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexPositionColor.cs
@@ -0,0 +1,74 @@
+using System;
+using System.Runtime.Serialization;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    [DataContract]
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+	public struct VertexPositionColor : IVertexType
+	{
+        [DataMember]
+		public Vector3 Position;
+        
+        [DataMember]
+		public Color Color;
+
+		public static readonly VertexDeclaration VertexDeclaration;
+
+		public VertexPositionColor(Vector3 position, Color color)
+		{
+			this.Position = position;
+			Color = color;
+		}
+
+		VertexDeclaration IVertexType.VertexDeclaration
+        {
+			get
+            {
+				return VertexDeclaration;
+			}
+		}
+
+	    public override int GetHashCode()
+	    {
+	        unchecked
+	        {
+	            return (Position.GetHashCode() * 397) ^ Color.GetHashCode();
+	        }
+	    }
+
+	    public override string ToString()
+		{
+            return "{{Position:" + this.Position + " Color:" + this.Color + "}}";
+		}
+
+		public static bool operator == (VertexPositionColor left, VertexPositionColor right)
+		{
+			return ((left.Color == right.Color) && (left.Position == right.Position));
+		}
+
+		public static bool operator != (VertexPositionColor left, VertexPositionColor right)
+		{
+			return !(left == right);
+		}
+
+		public override bool Equals(object obj)
+		{
+			if (obj == null) {
+				return false;
+			}
+			if (obj.GetType () != base.GetType ()) {
+				return false;
+			}
+			return (this == ((VertexPositionColor)obj));
+		}
+
+		static VertexPositionColor()
+		{
+			VertexElement[] elements = new VertexElement[] { new VertexElement (0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0), new VertexElement (12, VertexElementFormat.Color, VertexElementUsage.Color, 0) };
+			VertexDeclaration declaration = new VertexDeclaration (elements);
+			VertexDeclaration = declaration;
+		}
+	}
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexPositionColorTexture.cs b/MonoGame.Framework/Graphics/Vertices/VertexPositionColorTexture.cs
new file mode 100644
index 00000000000..7e17008373f
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexPositionColorTexture.cs
@@ -0,0 +1,76 @@
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct VertexPositionColorTexture : IVertexType
+    {
+        public Vector3 Position;
+        public Color Color;
+        public Vector2 TextureCoordinate;
+        public static readonly VertexDeclaration VertexDeclaration;
+
+        public VertexPositionColorTexture(Vector3 position, Color color, Vector2 textureCoordinate)
+        {
+            Position = position;
+            Color = color;
+            TextureCoordinate = textureCoordinate;
+        }
+		
+        VertexDeclaration IVertexType.VertexDeclaration
+        {
+            get
+            {
+                return VertexDeclaration;
+            }
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = Position.GetHashCode();
+                hashCode = (hashCode * 397) ^ Color.GetHashCode();
+                hashCode = (hashCode * 397) ^ TextureCoordinate.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        public override string ToString()
+        {
+            return "{{Position:" + this.Position + " Color:" + this.Color + " TextureCoordinate:" + this.TextureCoordinate + "}}";
+        }
+
+        public static bool operator ==(VertexPositionColorTexture left, VertexPositionColorTexture right)
+        {
+            return (((left.Position == right.Position) && (left.Color == right.Color)) && (left.TextureCoordinate == right.TextureCoordinate));
+        }
+
+        public static bool operator !=(VertexPositionColorTexture left, VertexPositionColorTexture right)
+        {
+            return !(left == right);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+                return false;
+
+            if (obj.GetType() != base.GetType())
+                return false;
+
+            return (this == ((VertexPositionColorTexture)obj));
+        }
+
+        static VertexPositionColorTexture()
+        {
+            var elements = new VertexElement[] 
+            { 
+                new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0), 
+                new VertexElement(12, VertexElementFormat.Color, VertexElementUsage.Color, 0), 
+                new VertexElement(16, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 0) 
+            };
+            VertexDeclaration = new VertexDeclaration(elements);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexPositionNormalTexture.cs b/MonoGame.Framework/Graphics/Vertices/VertexPositionNormalTexture.cs
new file mode 100644
index 00000000000..094a332dd22
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexPositionNormalTexture.cs
@@ -0,0 +1,73 @@
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct VertexPositionNormalTexture : IVertexType
+    {
+        public Vector3 Position;
+        public Vector3 Normal;
+        public Vector2 TextureCoordinate;
+        public static readonly VertexDeclaration VertexDeclaration;
+        public VertexPositionNormalTexture(Vector3 position, Vector3 normal, Vector2 textureCoordinate)
+        {
+            this.Position = position;
+            this.Normal = normal;
+            this.TextureCoordinate = textureCoordinate;
+        }
+
+        VertexDeclaration IVertexType.VertexDeclaration
+        {
+            get
+            {
+                return VertexDeclaration;
+            }
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = Position.GetHashCode();
+                hashCode = (hashCode * 397) ^ Normal.GetHashCode();
+                hashCode = (hashCode * 397) ^ TextureCoordinate.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        public override string ToString()
+        {
+            return "{{Position:" + this.Position + " Normal:" + this.Normal + " TextureCoordinate:" + this.TextureCoordinate + "}}";
+        }
+
+        public static bool operator ==(VertexPositionNormalTexture left, VertexPositionNormalTexture right)
+        {
+            return (((left.Position == right.Position) && (left.Normal == right.Normal)) && (left.TextureCoordinate == right.TextureCoordinate));
+        }
+
+        public static bool operator !=(VertexPositionNormalTexture left, VertexPositionNormalTexture right)
+        {
+            return !(left == right);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+            if (obj.GetType() != base.GetType())
+            {
+                return false;
+            }
+            return (this == ((VertexPositionNormalTexture)obj));
+        }
+
+        static VertexPositionNormalTexture()
+        {
+            VertexElement[] elements = new VertexElement[] { new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0), new VertexElement(12, VertexElementFormat.Vector3, VertexElementUsage.Normal, 0), new VertexElement(0x18, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 0) };
+            VertexDeclaration declaration = new VertexDeclaration(elements);
+            VertexDeclaration = declaration;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Vertices/VertexPositionTexture.cs b/MonoGame.Framework/Graphics/Vertices/VertexPositionTexture.cs
new file mode 100644
index 00000000000..9b5b3703a79
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Vertices/VertexPositionTexture.cs
@@ -0,0 +1,69 @@
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    [StructLayout(LayoutKind.Sequential, Pack=1)]
+    public struct VertexPositionTexture : IVertexType
+    {
+        public Vector3 Position;
+        public Vector2 TextureCoordinate;
+        public static readonly VertexDeclaration VertexDeclaration;
+        public VertexPositionTexture(Vector3 position, Vector2 textureCoordinate)
+        {
+            this.Position = position;
+            this.TextureCoordinate = textureCoordinate;
+        }
+
+        VertexDeclaration IVertexType.VertexDeclaration
+        {
+            get
+            {
+                return VertexDeclaration;
+            }
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (Position.GetHashCode() * 397) ^ TextureCoordinate.GetHashCode();
+            }
+        }
+
+        public override string ToString()
+        {
+            return "{{Position:" + this.Position + " TextureCoordinate:" + this.TextureCoordinate + "}}";
+        }
+
+        public static bool operator ==(VertexPositionTexture left, VertexPositionTexture right)
+        {
+            return ((left.Position == right.Position) && (left.TextureCoordinate == right.TextureCoordinate));
+        }
+
+        public static bool operator !=(VertexPositionTexture left, VertexPositionTexture right)
+        {
+            return !(left == right);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+            if (obj.GetType() != base.GetType())
+            {
+                return false;
+            }
+            return (this == ((VertexPositionTexture)obj));
+        }
+
+        static VertexPositionTexture()
+        {
+            VertexElement[] elements = new VertexElement[] { new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0), new VertexElement(12, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 0) };
+            VertexDeclaration declaration = new VertexDeclaration(elements);
+            VertexDeclaration = declaration;
+        }
+
+    }
+}
diff --git a/MonoGame.Framework/Graphics/Viewport.cs b/MonoGame.Framework/Graphics/Viewport.cs
new file mode 100644
index 00000000000..0da15e854c5
--- /dev/null
+++ b/MonoGame.Framework/Graphics/Viewport.cs
@@ -0,0 +1,263 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.Graphics
+{
+    /// <summary>
+    /// Describes the view bounds for render-target surface.
+    /// </summary>
+    [DataContract]
+    public struct Viewport
+    {
+		private int x;
+		private int y;
+		private int width;
+		private int height;
+		private float minDepth;
+		private float maxDepth;
+
+        #region Properties
+
+        /// <summary>
+        /// The height of the bounds in pixels.
+        /// </summary>
+        [DataMember]
+        public int Height
+        {
+			get {
+				return this.height;
+			}
+			set {
+				height = value;
+			}
+		}
+
+        /// <summary>
+        /// The upper limit of depth of this viewport.
+        /// </summary>
+        [DataMember]
+        public float MaxDepth
+        {
+			get {
+				return this.maxDepth;
+			}
+			set {
+				maxDepth = value;
+			}
+		}
+
+        /// <summary>
+        /// The lower limit of depth of this viewport.
+        /// </summary>
+        [DataMember]
+        public float MinDepth
+        {
+			get {
+				return this.minDepth;
+			}
+			set {
+				minDepth = value;
+			}
+		}
+
+        /// <summary>
+        /// The width of the bounds in pixels.
+        /// </summary>
+        [DataMember]
+        public int Width
+        {
+			get {
+				return this.width;
+			}
+			set {
+				width = value;
+			}
+		}
+
+        /// <summary>
+        /// The y coordinate of the beginning of this viewport.
+        /// </summary>
+        [DataMember]
+        public int Y
+        {
+			get {
+				return this.y;
+
+			}
+			set {
+				y = value;
+			}
+		}
+
+        /// <summary>
+        /// The x coordinate of the beginning of this viewport.
+        /// </summary>
+        [DataMember]
+        public int X 
+		{
+			get{ return x;}
+			set{ x = value;}
+		}
+
+		#endregion
+		
+        /// <summary>
+        /// Gets the aspect ratio of this <see cref="Viewport"/>, which is width / height. 
+        /// </summary>
+		public float AspectRatio 
+		{
+			get
+			{
+				if ((height != 0) && (width != 0))
+				{
+					return (((float) width)/((float)height));
+				}
+				return 0f;
+			}
+		}
+		
+        /// <summary>
+        /// Gets or sets a boundary of this <see cref="Viewport"/>.
+        /// </summary>
+		public Rectangle Bounds 
+		{
+            get
+            {
+                return new Rectangle(x, y, width, height);
+            }
+				
+			set
+			{				
+				x = value.X;
+				y = value.Y;
+				width = value.Width;
+				height = value.Height;
+			}
+		}
+
+        /// <summary>
+        /// Returns the subset of the viewport that is guaranteed to be visible on a lower quality display.
+        /// </summary>
+		public Rectangle TitleSafeArea 
+		{
+			get { return GraphicsDevice.GetTitleSafeArea(x, y, width, height); }
+		}
+
+        /// <summary>
+        /// Constructs a viewport from the given values. The <see cref="MinDepth"/> will be 0.0 and <see cref="MaxDepth"/> will be 1.0.
+        /// </summary>
+        /// <param name="x">The x coordinate of the upper-left corner of the view bounds in pixels.</param>
+        /// <param name="y">The y coordinate of the upper-left corner of the view bounds in pixels.</param>
+        /// <param name="width">The width of the view bounds in pixels.</param>
+        /// <param name="height">The height of the view bounds in pixels.</param>
+        public Viewport(int x, int y, int width, int height)
+		{
+			this.x = x;
+		    this.y = y;
+		    this.width = width;
+		    this.height = height;
+		    this.minDepth = 0.0f;
+		    this.maxDepth = 1.0f;
+		}
+
+        /// <summary>
+        /// Constructs a viewport from the given values.
+        /// </summary>
+        /// <param name="x">The x coordinate of the upper-left corner of the view bounds in pixels.</param>
+        /// <param name="y">The y coordinate of the upper-left corner of the view bounds in pixels.</param>
+        /// <param name="width">The width of the view bounds in pixels.</param>
+        /// <param name="height">The height of the view bounds in pixels.</param>
+        /// <param name="minDepth">The lower limit of depth.</param>
+        /// <param name="maxDepth">The upper limit of depth.</param>
+        public Viewport(int x, int y, int width, int height,float minDepth,float maxDepth)
+        {
+            this.x = x;
+            this.y = y;
+            this.width = width;
+            this.height = height;
+            this.minDepth = minDepth;
+            this.maxDepth = maxDepth;
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="Viewport"/> struct.
+        /// </summary>
+        /// <param name="bounds">A <see cref="Rectangle"/> that defines the location and size of the <see cref="Viewport"/> in a render target.</param>
+		public Viewport(Rectangle bounds) : this(bounds.X, bounds.Y, bounds.Width, bounds.Height)
+		{
+		}
+
+        /// <summary>
+        /// Projects a <see cref="Vector3"/> from world space into screen space.
+        /// </summary>
+        /// <param name="source">The <see cref="Vector3"/> to project.</param>
+        /// <param name="projection">The projection <see cref="Matrix"/>.</param>
+        /// <param name="view">The view <see cref="Matrix"/>.</param>
+        /// <param name="world">The world <see cref="Matrix"/>.</param>
+        /// <returns></returns>
+        public Vector3 Project(Vector3 source, Matrix projection, Matrix view, Matrix world)
+        {
+            Matrix matrix = Matrix.Multiply(Matrix.Multiply(world, view), projection);
+		    Vector3 vector = Vector3.Transform(source, matrix);
+		    float a = (((source.X * matrix.M14) + (source.Y * matrix.M24)) + (source.Z * matrix.M34)) + matrix.M44;
+		    if (!WithinEpsilon(a, 1f))
+		    {
+		        vector.X = vector.X / a;
+		        vector.Y = vector.Y / a;
+		        vector.Z = vector.Z / a;
+		    }
+		    vector.X = (((vector.X + 1f) * 0.5f) * this.width) + this.x;
+		    vector.Y = (((-vector.Y + 1f) * 0.5f) * this.height) + this.y;
+		    vector.Z = (vector.Z * (this.maxDepth - this.minDepth)) + this.minDepth;
+		    return vector;
+        }
+
+        /// <summary>
+        /// Unprojects a <see cref="Vector3"/> from screen space into world space.
+        /// Note source.Z must be less than or equal to MaxDepth.
+        /// </summary>
+        /// <param name="source">The <see cref="Vector3"/> to unproject.</param>
+        /// <param name="projection">The projection <see cref="Matrix"/>.</param>
+        /// <param name="view">The view <see cref="Matrix"/>.</param>
+        /// <param name="world">The world <see cref="Matrix"/>.</param>
+        /// <returns></returns>
+        public Vector3 Unproject(Vector3 source, Matrix projection, Matrix view, Matrix world)
+        {
+             Matrix matrix = Matrix.Invert(Matrix.Multiply(Matrix.Multiply(world, view), projection));
+		    source.X = (((source.X - this.x) / ((float) this.width)) * 2f) - 1f;
+		    source.Y = -((((source.Y - this.y) / ((float) this.height)) * 2f) - 1f);
+		    source.Z = (source.Z - this.minDepth) / (this.maxDepth - this.minDepth);
+		    Vector3 vector = Vector3.Transform(source, matrix);
+		    float a = (((source.X * matrix.M14) + (source.Y * matrix.M24)) + (source.Z * matrix.M34)) + matrix.M44;
+		    if (!WithinEpsilon(a, 1f))
+		    {
+		        vector.X = vector.X / a;
+		        vector.Y = vector.Y / a;
+		        vector.Z = vector.Z / a;
+		    }
+		    return vector;
+
+        }
+		
+		private static bool WithinEpsilon(float a, float b)
+		{
+		    float num = a - b;
+		    return ((-1.401298E-45f <= num) && (num <= float.Epsilon));
+		}
+
+        /// <summary>
+        /// Returns a <see cref="String"/> representation of this <see cref="Viewport"/> in the format:
+        /// {X:[<see cref="X"/>] Y:[<see cref="Y"/>] Width:[<see cref="Width"/>] Height:[<see cref="Height"/>] MinDepth:[<see cref="MinDepth"/>] MaxDepth:[<see cref="MaxDepth"/>]}
+        /// </summary>
+        /// <returns>A <see cref="String"/> representation of this <see cref="Viewport"/>.</returns>
+        public override string ToString ()
+	    {
+	        return "{X:" + x + " Y:" + y + " Width:" + width + " Height:" + height + " MinDepth:" + minDepth + " MaxDepth:" + maxDepth + "}";
+	    }
+    }
+}
+
diff --git a/MonoGame.Framework/Graphics/WindowInfo.SDL.cs b/MonoGame.Framework/Graphics/WindowInfo.SDL.cs
new file mode 100644
index 00000000000..28ada796b39
--- /dev/null
+++ b/MonoGame.Framework/Graphics/WindowInfo.SDL.cs
@@ -0,0 +1,14 @@
+using System;
+
+namespace MonoGame.OpenGL
+{
+    internal class WindowInfo : IWindowInfo
+    {
+        public IntPtr Handle { get; private set; }
+
+        public WindowInfo(IntPtr handle)
+        {
+            Handle = handle;
+        }
+    }
+}
diff --git a/MonoGame.Framework/GraphicsDeviceInformation.cs b/MonoGame.Framework/GraphicsDeviceInformation.cs
new file mode 100644
index 00000000000..01ade410270
--- /dev/null
+++ b/MonoGame.Framework/GraphicsDeviceInformation.cs
@@ -0,0 +1,35 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// The settings used in creation of the graphics device.
+    /// See <see cref="GraphicsDeviceManager.PreparingDeviceSettings"/>.
+    /// </summary>
+    public class GraphicsDeviceInformation
+    {	
+        /// <summary>
+        /// The graphics adapter on which the graphics device will be created.
+        /// </summary>
+        /// <remarks>
+        /// This is only valid on desktop systems where multiple graphics 
+        /// adapters are possible.  Defaults to <see cref="GraphicsAdapter.DefaultAdapter"/>.
+        /// </remarks>
+        public GraphicsAdapter Adapter { get; set; }
+        
+        /// <summary>
+        /// The requested graphics device feature set. 
+        /// </summary>
+        public GraphicsProfile GraphicsProfile { get; set; }
+        
+        /// <summary>
+        /// The settings that define how graphics will be presented to the display.
+        /// </summary>
+        public PresentationParameters PresentationParameters { get; set; }
+    }
+}
+
diff --git a/MonoGame.Framework/GraphicsDeviceManager.Legacy.cs b/MonoGame.Framework/GraphicsDeviceManager.Legacy.cs
new file mode 100644
index 00000000000..d9080735a20
--- /dev/null
+++ b/MonoGame.Framework/GraphicsDeviceManager.Legacy.cs
@@ -0,0 +1,633 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input.Touch;
+
+#if WINDOWS_UAP
+using Windows.UI.Xaml.Controls;
+#endif
+
+#if ANDROID
+using Android.Views;
+#endif
+
+namespace Microsoft.Xna.Framework
+{
+    public class GraphicsDeviceManager : IGraphicsDeviceService, IDisposable, IGraphicsDeviceManager
+    {
+        private Game _game;
+        private GraphicsDevice _graphicsDevice;
+        private int _preferredBackBufferHeight;
+        private int _preferredBackBufferWidth;
+        private SurfaceFormat _preferredBackBufferFormat;
+        private DepthFormat _preferredDepthStencilFormat;
+        private bool _preferMultiSampling;
+        private DisplayOrientation _supportedOrientations;
+        private bool _synchronizedWithVerticalRetrace = true;
+        private bool _drawBegun;
+        bool disposed;
+        private bool _hardwareModeSwitch = true;
+
+#if (WINDOWS || WINDOWS_UAP) && DIRECTX
+        private bool _firstLaunch = true;
+#endif
+
+#if !WINRT || WINDOWS_UAP
+        private bool _wantFullScreen = false;
+#endif
+        public static readonly int DefaultBackBufferHeight = 480;
+        public static readonly int DefaultBackBufferWidth = 800;
+
+        public GraphicsDeviceManager(Game game)
+        {
+            if (game == null)
+                throw new ArgumentNullException("The game cannot be null!");
+
+            _game = game;
+
+            _supportedOrientations = DisplayOrientation.Default;
+
+#if WINDOWS || MONOMAC || DESKTOPGL
+            _preferredBackBufferHeight = DefaultBackBufferHeight;
+            _preferredBackBufferWidth = DefaultBackBufferWidth;
+#else
+            // Preferred buffer width/height is used to determine default supported orientations,
+            // so set the default values to match Xna behaviour of landscape only by default.
+            // Note also that it's using the device window dimensions.
+            _preferredBackBufferWidth = Math.Max(_game.Window.ClientBounds.Height, _game.Window.ClientBounds.Width);
+            _preferredBackBufferHeight = Math.Min(_game.Window.ClientBounds.Height, _game.Window.ClientBounds.Width);
+#endif
+
+            _preferredBackBufferFormat = SurfaceFormat.Color;
+            _preferredDepthStencilFormat = DepthFormat.Depth24;
+            _synchronizedWithVerticalRetrace = true;
+
+            // XNA would read this from the manifest, but it would always default
+            // to Reach unless changed.  So lets mimic that without the manifest bit.
+            GraphicsProfile = GraphicsProfile.Reach;
+
+            if (_game.Services.GetService(typeof(IGraphicsDeviceManager)) != null)
+                throw new ArgumentException("Graphics Device Manager Already Present");
+
+            _game.Services.AddService(typeof(IGraphicsDeviceManager), this);
+            _game.Services.AddService(typeof(IGraphicsDeviceService), this);
+        }
+
+        ~GraphicsDeviceManager()
+        {
+            Dispose(false);
+        }
+
+        public void CreateDevice()
+        {
+            Initialize();
+
+            OnDeviceCreated(EventArgs.Empty);
+        }
+
+        public bool BeginDraw()
+        {
+            if (_graphicsDevice == null)
+                return false;
+
+            _drawBegun = true;
+            return true;
+        }
+
+        public void EndDraw()
+        {
+            if (_graphicsDevice != null && _drawBegun)
+            {
+                _drawBegun = false;
+                _graphicsDevice.Present();
+            }
+        }
+
+        #region IGraphicsDeviceService Members
+
+        public event EventHandler<EventArgs> DeviceCreated;
+        public event EventHandler<EventArgs> DeviceDisposing;
+        public event EventHandler<EventArgs> DeviceReset;
+        public event EventHandler<EventArgs> DeviceResetting;
+        public event EventHandler<PreparingDeviceSettingsEventArgs> PreparingDeviceSettings;
+
+        // FIXME: Why does the GraphicsDeviceManager not know enough about the
+        //        GraphicsDevice to raise these events without help?
+        internal void OnDeviceDisposing(EventArgs e)
+        {
+            EventHelpers.Raise(this, DeviceDisposing, e);
+        }
+
+        // FIXME: Why does the GraphicsDeviceManager not know enough about the
+        //        GraphicsDevice to raise these events without help?
+        internal void OnDeviceResetting(EventArgs e)
+        {
+            EventHelpers.Raise(this, DeviceResetting, e);
+        }
+
+        // FIXME: Why does the GraphicsDeviceManager not know enough about the
+        //        GraphicsDevice to raise these events without help?
+        internal void OnDeviceReset(EventArgs e)
+        {
+            EventHelpers.Raise(this, DeviceReset, e);
+        }
+
+        // FIXME: Why does the GraphicsDeviceManager not know enough about the
+        //        GraphicsDevice to raise these events without help?
+        internal void OnDeviceCreated(EventArgs e)
+        {
+            EventHelpers.Raise(this, DeviceCreated, e);
+        }
+
+        #endregion
+
+        #region IDisposable Members
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposed)
+            {
+                if (disposing)
+                {
+                    if (_graphicsDevice != null)
+                    {
+                        _graphicsDevice.Dispose();
+                        _graphicsDevice = null;
+                    }
+                }
+                disposed = true;
+            }
+        }
+
+        #endregion
+
+        public void ApplyChanges()
+        {
+            // Calling ApplyChanges() before CreateDevice() should have no effect
+            if (_graphicsDevice == null)
+                return;
+
+#if WINDOWS_UAP
+
+            // TODO:  Does this need to occur here?
+            _game.Window.SetSupportedOrientations(_supportedOrientations);
+
+            _graphicsDevice.PresentationParameters.BackBufferFormat = _preferredBackBufferFormat;
+            _graphicsDevice.PresentationParameters.BackBufferWidth = _preferredBackBufferWidth;
+            _graphicsDevice.PresentationParameters.BackBufferHeight = _preferredBackBufferHeight;
+            _graphicsDevice.PresentationParameters.DepthStencilFormat = _preferredDepthStencilFormat;
+            
+            // TODO: We probably should be resetting the whole device
+            // if this changes as we are targeting a different 
+            // hardware feature level.
+            _graphicsDevice.GraphicsProfile = GraphicsProfile;
+
+#if WINDOWS_UAP
+			_graphicsDevice.PresentationParameters.DeviceWindowHandle = IntPtr.Zero;
+			_graphicsDevice.PresentationParameters.SwapChainPanel = this.SwapChainPanel;
+            _graphicsDevice.PresentationParameters.IsFullScreen = _wantFullScreen;
+#else
+            _graphicsDevice.PresentationParameters.IsFullScreen = false;
+
+			// The graphics device can use a XAML panel or a window
+			// to created the default swapchain target.
+            if (this.SwapChainBackgroundPanel != null)
+            {
+                _graphicsDevice.PresentationParameters.DeviceWindowHandle = IntPtr.Zero;
+                _graphicsDevice.PresentationParameters.SwapChainBackgroundPanel = this.SwapChainBackgroundPanel;
+            }
+            else
+            {
+                _graphicsDevice.PresentationParameters.DeviceWindowHandle = _game.Window.Handle;
+                _graphicsDevice.PresentationParameters.SwapChainBackgroundPanel = null;
+            }
+#endif
+			// Update the back buffer.
+			_graphicsDevice.CreateSizeDependentResources();
+            _graphicsDevice.ApplyRenderTargets(null);
+
+#if WINDOWS_UAP
+            ((UAPGameWindow)_game.Window).SetClientSize(_preferredBackBufferWidth, _preferredBackBufferHeight);
+#endif
+
+#elif WINDOWS && DIRECTX
+
+            _graphicsDevice.PresentationParameters.BackBufferFormat = _preferredBackBufferFormat;
+            _graphicsDevice.PresentationParameters.BackBufferWidth = _preferredBackBufferWidth;
+            _graphicsDevice.PresentationParameters.BackBufferHeight = _preferredBackBufferHeight;
+            _graphicsDevice.PresentationParameters.DepthStencilFormat = _preferredDepthStencilFormat;
+            _graphicsDevice.PresentationParameters.PresentationInterval = _synchronizedWithVerticalRetrace ? PresentInterval.Default : PresentInterval.Immediate;
+            _graphicsDevice.PresentationParameters.IsFullScreen = _wantFullScreen;
+
+            // TODO: We probably should be resetting the whole 
+            // device if this changes as we are targeting a different
+            // hardware feature level.
+            _graphicsDevice.GraphicsProfile = GraphicsProfile;
+
+            _graphicsDevice.PresentationParameters.DeviceWindowHandle = _game.Window.Handle;
+
+            // Update the back buffer.
+            _graphicsDevice.CreateSizeDependentResources();
+            _graphicsDevice.ApplyRenderTargets(null);
+
+            ((MonoGame.Framework.WinFormsGamePlatform)_game.Platform).ResetWindowBounds();
+
+#elif DESKTOPGL
+            var displayIndex = Sdl.Window.GetDisplayIndex (SdlGameWindow.Instance.Handle);
+            var displayName = Sdl.Display.GetDisplayName (displayIndex);
+
+            _graphicsDevice.PresentationParameters.BackBufferFormat = _preferredBackBufferFormat;
+            _graphicsDevice.PresentationParameters.BackBufferWidth = _preferredBackBufferWidth;
+            _graphicsDevice.PresentationParameters.BackBufferHeight = _preferredBackBufferHeight;
+            _graphicsDevice.PresentationParameters.DepthStencilFormat = _preferredDepthStencilFormat;
+            _graphicsDevice.PresentationParameters.PresentationInterval = _synchronizedWithVerticalRetrace ? PresentInterval.Default : PresentInterval.Immediate;
+            _graphicsDevice.PresentationParameters.IsFullScreen = _wantFullScreen;
+
+            //Set the swap interval based on if vsync is desired or not.
+            //See GetSwapInterval for more details
+            int swapInterval;
+            if (_synchronizedWithVerticalRetrace)
+                swapInterval = _graphicsDevice.PresentationParameters.PresentationInterval.GetSwapInterval();
+            else
+                swapInterval = 0;
+            _graphicsDevice.Context.SwapInterval = swapInterval;
+
+            _graphicsDevice.ApplyRenderTargets (null);
+
+            _game.Platform.BeginScreenDeviceChange (GraphicsDevice.PresentationParameters.IsFullScreen);
+            _game.Platform.EndScreenDeviceChange (displayName, GraphicsDevice.PresentationParameters.BackBufferWidth, GraphicsDevice.PresentationParameters.BackBufferHeight);
+
+#elif MONOMAC
+            _graphicsDevice.PresentationParameters.IsFullScreen = _wantFullScreen;
+
+            // TODO: Implement multisampling (aka anti-alising) for all platforms!
+
+			_game.applyChanges(this);
+#else
+
+#if ANDROID
+            // Trigger a change in orientation in case the supported orientations have changed
+            ((AndroidGameWindow)_game.Window).SetOrientation(_game.Window.CurrentOrientation, false);
+#endif
+            // Ensure the presentation parameter orientation and buffer size matches the window
+            _graphicsDevice.PresentationParameters.DisplayOrientation = _game.Window.CurrentOrientation;
+
+            // Set the presentation parameters' actual buffer size to match the orientation
+            bool isLandscape = (0 != (_game.Window.CurrentOrientation & (DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight)));
+            int w = PreferredBackBufferWidth;
+            int h = PreferredBackBufferHeight;
+
+            _graphicsDevice.PresentationParameters.BackBufferWidth = isLandscape ? Math.Max(w, h) : Math.Min(w, h);
+            _graphicsDevice.PresentationParameters.BackBufferHeight = isLandscape ? Math.Min(w, h) : Math.Max(w, h);
+
+            ResetClientBounds();
+#endif
+
+            // Set the new display size on the touch panel.
+            //
+            // TODO: In XNA this seems to be done as part of the 
+            // GraphicsDevice.DeviceReset event... we need to get 
+            // those working.
+            //
+            TouchPanel.DisplayWidth = _graphicsDevice.PresentationParameters.BackBufferWidth;
+            TouchPanel.DisplayHeight = _graphicsDevice.PresentationParameters.BackBufferHeight;
+
+#if (WINDOWS || WINDOWS_UAP) && DIRECTX
+
+            if (!_firstLaunch)
+            {
+                if (IsFullScreen)
+                {
+                    _game.Platform.EnterFullScreen();
+                }
+                else
+                {
+                   _game.Platform.ExitFullScreen();
+                }
+            }
+            _firstLaunch = false;
+#endif
+        }
+
+        private void Initialize()
+        {
+            var presentationParameters = new PresentationParameters();
+            presentationParameters.DepthStencilFormat = DepthFormat.Depth24;
+
+#if (WINDOWS || WINRT) && !DESKTOPGL
+            _game.Window.SetSupportedOrientations(_supportedOrientations);
+
+            presentationParameters.BackBufferFormat = _preferredBackBufferFormat;
+            presentationParameters.BackBufferWidth = _preferredBackBufferWidth;
+            presentationParameters.BackBufferHeight = _preferredBackBufferHeight;
+            presentationParameters.DepthStencilFormat = _preferredDepthStencilFormat;
+            presentationParameters.IsFullScreen = false;
+
+#if WINDOWS_UAP
+			presentationParameters.DeviceWindowHandle = IntPtr.Zero;
+			presentationParameters.SwapChainPanel = this.SwapChainPanel;
+#else
+            presentationParameters.DeviceWindowHandle = _game.Window.Handle;
+#endif
+
+#else
+
+#if MONOMAC || DESKTOPGL
+            presentationParameters.IsFullScreen = _wantFullScreen;
+#elif WEB
+            presentationParameters.IsFullScreen = false;
+#else
+            // Set "full screen"  as default
+            presentationParameters.IsFullScreen = true;
+#endif // MONOMAC
+
+#endif // WINDOWS || WINRT
+
+            // TODO: Implement multisampling (aka anti-alising) for all platforms!
+            var preparingDeviceSettingsHandler = PreparingDeviceSettings;
+
+            if (preparingDeviceSettingsHandler != null)
+            {
+                GraphicsDeviceInformation gdi = new GraphicsDeviceInformation();
+                gdi.GraphicsProfile = GraphicsProfile; // Microsoft defaults this to Reach.
+                gdi.Adapter = GraphicsAdapter.DefaultAdapter;
+                gdi.PresentationParameters = presentationParameters;
+                PreparingDeviceSettingsEventArgs pe = new PreparingDeviceSettingsEventArgs(gdi);
+                preparingDeviceSettingsHandler(this, pe);
+                presentationParameters = pe.GraphicsDeviceInformation.PresentationParameters;
+                GraphicsProfile = pe.GraphicsDeviceInformation.GraphicsProfile;
+            }
+
+            // Needs to be before ApplyChanges()
+            _graphicsDevice = new GraphicsDevice(GraphicsAdapter.DefaultAdapter, GraphicsProfile, presentationParameters);
+
+#if !MONOMAC
+            ApplyChanges();
+#endif
+
+            // Set the new display size on the touch panel.
+            //
+            // TODO: In XNA this seems to be done as part of the 
+            // GraphicsDevice.DeviceReset event... we need to get 
+            // those working.
+            //
+            TouchPanel.DisplayWidth = _graphicsDevice.PresentationParameters.BackBufferWidth;
+            TouchPanel.DisplayHeight = _graphicsDevice.PresentationParameters.BackBufferHeight;
+            TouchPanel.DisplayOrientation = _graphicsDevice.PresentationParameters.DisplayOrientation;
+        }
+
+        public void ToggleFullScreen()
+        {
+            IsFullScreen = !IsFullScreen;
+
+#if ((WINDOWS || WINDOWS_UAP) && DIRECTX) || DESKTOPGL
+            ApplyChanges();
+#endif
+        }
+
+
+#if WINDOWS_UAP
+        [CLSCompliant(false)]
+        public SwapChainPanel SwapChainPanel { get; set; }
+#endif
+
+        public GraphicsProfile GraphicsProfile { get; set; }
+
+        public GraphicsDevice GraphicsDevice
+        {
+            get
+            {
+                return _graphicsDevice;
+            }
+        }
+
+        public bool IsFullScreen
+        {
+            get
+            {
+#if WINDOWS_UAP
+                return _wantFullScreen;
+#elif WINRT
+                return true;
+#else
+                if (_graphicsDevice != null)
+                    return _graphicsDevice.PresentationParameters.IsFullScreen;
+                return _wantFullScreen;
+#endif
+            }
+            set
+            {
+#if WINDOWS_UAP
+                _wantFullScreen = value;
+#elif WINRT
+                // Just ignore this as it is not relevant on Windows 8
+#elif WINDOWS && DIRECTX
+                _wantFullScreen = value;
+#else
+                _wantFullScreen = value;
+                if (_graphicsDevice != null)
+                {
+                    _graphicsDevice.PresentationParameters.IsFullScreen = value;
+#if ANDROID
+                    ForceSetFullScreen();
+#endif
+                }
+#endif
+            }
+        }
+
+#if ANDROID
+        internal void ForceSetFullScreen()
+        {
+            if (IsFullScreen)
+			{
+				Game.Activity.Window.ClearFlags(Android.Views.WindowManagerFlags.ForceNotFullscreen);
+                Game.Activity.Window.SetFlags(WindowManagerFlags.Fullscreen, WindowManagerFlags.Fullscreen);
+			}
+            else
+                Game.Activity.Window.SetFlags(WindowManagerFlags.ForceNotFullscreen, WindowManagerFlags.ForceNotFullscreen);
+        }
+#endif
+
+        /// <summary>
+        /// Gets or sets the boolean which defines how window switches from windowed to fullscreen state.
+        /// "Hard" mode(true) is slow to switch, but more effecient for performance, while "soft" mode(false) is vice versa.
+        /// The default value is <c>true</c>.
+        /// </summary>
+        public bool HardwareModeSwitch
+        {
+            get { return _hardwareModeSwitch; }
+            set
+            {
+                _hardwareModeSwitch = value;
+            }
+        }
+
+        public bool PreferMultiSampling
+        {
+            get
+            {
+                return _preferMultiSampling;
+            }
+            set
+            {
+                _preferMultiSampling = value;
+            }
+        }
+
+        public SurfaceFormat PreferredBackBufferFormat
+        {
+            get
+            {
+                return _preferredBackBufferFormat;
+            }
+            set
+            {
+                _preferredBackBufferFormat = value;
+            }
+        }
+
+        public int PreferredBackBufferHeight
+        {
+            get
+            {
+                return _preferredBackBufferHeight;
+            }
+            set
+            {
+                _preferredBackBufferHeight = value;
+            }
+        }
+
+        public int PreferredBackBufferWidth
+        {
+            get
+            {
+                return _preferredBackBufferWidth;
+            }
+            set
+            {
+                _preferredBackBufferWidth = value;
+            }
+        }
+
+        public DepthFormat PreferredDepthStencilFormat
+        {
+            get
+            {
+                return _preferredDepthStencilFormat;
+            }
+            set
+            {
+                _preferredDepthStencilFormat = value;
+            }
+        }
+
+        public bool SynchronizeWithVerticalRetrace
+        {
+            get
+            {
+                return _synchronizedWithVerticalRetrace;
+            }
+            set
+            {
+                _synchronizedWithVerticalRetrace = value;
+            }
+        }
+
+        public DisplayOrientation SupportedOrientations
+        {
+            get
+            {
+                return _supportedOrientations;
+            }
+            set
+            {
+                _supportedOrientations = value;
+                if (_game.Window != null)
+                    _game.Window.SetSupportedOrientations(_supportedOrientations);
+            }
+        }
+
+        /// <summary>
+        /// This method is used by MonoGame Android to adjust the game's drawn to area to fill
+        /// as much of the screen as possible whilst retaining the aspect ratio inferred from
+        /// aspectRatio = (PreferredBackBufferWidth / PreferredBackBufferHeight)
+        ///
+        /// NOTE: this is a hack that should be removed if proper back buffer to screen scaling
+        /// is implemented. To disable it's effect, in the game's constructor use:
+        ///
+        ///     graphics.IsFullScreen = true;
+        ///     graphics.PreferredBackBufferHeight = Window.ClientBounds.Height;
+        ///     graphics.PreferredBackBufferWidth = Window.ClientBounds.Width;
+        ///
+        /// </summary>
+        internal void ResetClientBounds()
+        {
+#if ANDROID
+            float preferredAspectRatio = (float)PreferredBackBufferWidth /
+                                         (float)PreferredBackBufferHeight;
+            float displayAspectRatio = (float)GraphicsDevice.DisplayMode.Width / 
+                                       (float)GraphicsDevice.DisplayMode.Height;
+
+            float adjustedAspectRatio = preferredAspectRatio;
+
+            if ((preferredAspectRatio > 1.0f && displayAspectRatio < 1.0f) ||
+                (preferredAspectRatio < 1.0f && displayAspectRatio > 1.0f))
+            {
+                // Invert preferred aspect ratio if it's orientation differs from the display mode orientation.
+                // This occurs when user sets preferredBackBufferWidth/Height and also allows multiple supported orientations
+                adjustedAspectRatio = 1.0f / preferredAspectRatio;
+            }
+
+            const float EPSILON = 0.00001f;
+            var newClientBounds = new Rectangle();
+            if (displayAspectRatio > (adjustedAspectRatio + EPSILON))
+            {
+                // Fill the entire height and reduce the width to keep aspect ratio
+                newClientBounds.Height = _graphicsDevice.DisplayMode.Height;
+                newClientBounds.Width = (int)(newClientBounds.Height * adjustedAspectRatio);
+                newClientBounds.X = (_graphicsDevice.DisplayMode.Width - newClientBounds.Width) / 2;
+            }
+            else if (displayAspectRatio < (adjustedAspectRatio - EPSILON))
+            {
+                // Fill the entire width and reduce the height to keep aspect ratio
+                newClientBounds.Width = _graphicsDevice.DisplayMode.Width;
+                newClientBounds.Height = (int)(newClientBounds.Width / adjustedAspectRatio);
+                newClientBounds.Y = (_graphicsDevice.DisplayMode.Height - newClientBounds.Height) / 2;
+            }
+            else
+            {
+                // Set the ClientBounds to match the DisplayMode
+                newClientBounds.Width = GraphicsDevice.DisplayMode.Width;
+                newClientBounds.Height = GraphicsDevice.DisplayMode.Height;
+            }
+
+            // Ensure buffer size is reported correctly
+            _graphicsDevice.PresentationParameters.BackBufferWidth = newClientBounds.Width;
+            _graphicsDevice.PresentationParameters.BackBufferHeight = newClientBounds.Height;
+
+            // Set the veiwport so the (potentially) resized client bounds are drawn in the middle of the screen
+            _graphicsDevice.Viewport = new Viewport(newClientBounds.X, -newClientBounds.Y, newClientBounds.Width, newClientBounds.Height);
+
+            ((AndroidGameWindow)_game.Window).ChangeClientBounds(newClientBounds);
+
+            // Touch panel needs latest buffer size for scaling
+            TouchPanel.DisplayWidth = newClientBounds.Width;
+            TouchPanel.DisplayHeight = newClientBounds.Height;
+
+            Android.Util.Log.Debug("MonoGame", "GraphicsDeviceManager.ResetClientBounds: newClientBounds=" + newClientBounds.ToString());
+#endif
+        }
+
+    }
+}
diff --git a/MonoGame.Framework/GraphicsDeviceManager.SDL.cs b/MonoGame.Framework/GraphicsDeviceManager.SDL.cs
new file mode 100644
index 00000000000..03b50012b05
--- /dev/null
+++ b/MonoGame.Framework/GraphicsDeviceManager.SDL.cs
@@ -0,0 +1,49 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework
+{
+    public partial class GraphicsDeviceManager
+    {
+        partial void PlatformInitialize(PresentationParameters presentationParameters)
+        {
+            var surfaceFormat = _game.graphicsDeviceManager.PreferredBackBufferFormat.GetColorFormat();
+            var depthStencilFormat = _game.graphicsDeviceManager.PreferredDepthStencilFormat;
+
+            // TODO Need to get this data from the Presentation Parameters
+            Sdl.GL.SetAttribute(Sdl.GL.Attribute.RedSize, surfaceFormat.R);
+            Sdl.GL.SetAttribute(Sdl.GL.Attribute.GreenSize, surfaceFormat.G);
+            Sdl.GL.SetAttribute(Sdl.GL.Attribute.BlueSize, surfaceFormat.B);
+            Sdl.GL.SetAttribute(Sdl.GL.Attribute.AlphaSize, surfaceFormat.A);
+
+            switch (depthStencilFormat)
+            {
+                case DepthFormat.None:
+                    Sdl.GL.SetAttribute(Sdl.GL.Attribute.DepthSize, 0);
+                    Sdl.GL.SetAttribute(Sdl.GL.Attribute.StencilSize, 0);
+                    break;
+                case DepthFormat.Depth16:
+                    Sdl.GL.SetAttribute(Sdl.GL.Attribute.DepthSize, 16);
+                    Sdl.GL.SetAttribute(Sdl.GL.Attribute.StencilSize, 0);
+                    break;
+                case DepthFormat.Depth24:
+                    Sdl.GL.SetAttribute(Sdl.GL.Attribute.DepthSize, 24);
+                    Sdl.GL.SetAttribute(Sdl.GL.Attribute.StencilSize, 0);
+                    break;
+                case DepthFormat.Depth24Stencil8:
+                    Sdl.GL.SetAttribute(Sdl.GL.Attribute.DepthSize, 24);
+                    Sdl.GL.SetAttribute(Sdl.GL.Attribute.StencilSize, 8);
+                    break;
+            }
+
+            Sdl.GL.SetAttribute(Sdl.GL.Attribute.DoubleBuffer, 1);
+            Sdl.GL.SetAttribute(Sdl.GL.Attribute.ContextMajorVersion, 2);
+            Sdl.GL.SetAttribute(Sdl.GL.Attribute.ContextMinorVersion, 1);
+
+            ((SdlGameWindow)SdlGameWindow.Instance).CreateWindow();
+        }
+    }
+}
diff --git a/MonoGame.Framework/GraphicsDeviceManager.WinRT.cs b/MonoGame.Framework/GraphicsDeviceManager.WinRT.cs
new file mode 100644
index 00000000000..8c347b0111f
--- /dev/null
+++ b/MonoGame.Framework/GraphicsDeviceManager.WinRT.cs
@@ -0,0 +1,33 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+using Windows.UI.Xaml.Controls;
+
+namespace Microsoft.Xna.Framework
+{
+    partial class GraphicsDeviceManager
+    {
+        [CLSCompliant(false)] 
+        public SwapChainPanel SwapChainPanel { get; set; }
+
+        partial void PlatformPreparePresentationParameters(PresentationParameters presentationParameters)
+        {
+
+            // The graphics device can use a XAML panel or a window
+            // to created the default swapchain target.
+            if (SwapChainPanel != null)
+            {
+                presentationParameters.DeviceWindowHandle = IntPtr.Zero;
+                presentationParameters.SwapChainPanel = this.SwapChainPanel;
+           }
+            else
+            {
+                presentationParameters.DeviceWindowHandle = _game.Window.Handle;
+                presentationParameters.SwapChainPanel = null;
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/GraphicsDeviceManager.cs b/MonoGame.Framework/GraphicsDeviceManager.cs
new file mode 100644
index 00000000000..7e752fb9546
--- /dev/null
+++ b/MonoGame.Framework/GraphicsDeviceManager.cs
@@ -0,0 +1,575 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input.Touch;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Used to initialize and control the presentation of the graphics device.
+    /// </summary>
+    public partial class GraphicsDeviceManager : IGraphicsDeviceService, IDisposable, IGraphicsDeviceManager
+    {
+        private readonly Game _game;
+        private GraphicsDevice _graphicsDevice;
+        private bool _initialized = false;
+
+        private int _preferredBackBufferHeight;
+        private int _preferredBackBufferWidth;
+        private SurfaceFormat _preferredBackBufferFormat;
+        private DepthFormat _preferredDepthStencilFormat;
+        private bool _preferMultiSampling;
+        private DisplayOrientation _supportedOrientations;
+        private bool _synchronizedWithVerticalRetrace = true;
+        private bool _drawBegun;
+        private bool _disposed;
+        private bool _hardwareModeSwitch = true;
+        private bool _wantFullScreen;
+        private GraphicsProfile _graphicsProfile;
+        // dirty flag for ApplyChanges
+        private bool _shouldApplyChanges;
+
+        /// <summary>
+        /// The default back buffer width.
+        /// </summary>
+        public static readonly int DefaultBackBufferWidth = 800;
+
+        /// <summary>
+        /// The default back buffer height.
+        /// </summary>
+        public static readonly int DefaultBackBufferHeight = 480;
+
+        /// <summary>
+        /// Optional override for platform specific defaults.
+        /// </summary>
+        partial void PlatformConstruct();
+
+        /// <summary>
+        /// Associates this graphics device manager to a game instances.
+        /// </summary>
+        /// <param name="game">The game instance to attach.</param>
+        public GraphicsDeviceManager(Game game)
+        {
+            if (game == null)
+                throw new ArgumentNullException("game", "Game cannot be null.");
+
+            _game = game;
+
+            _supportedOrientations = DisplayOrientation.Default;
+            _preferredBackBufferFormat = SurfaceFormat.Color;
+            _preferredDepthStencilFormat = DepthFormat.Depth24;
+            _synchronizedWithVerticalRetrace = true;
+
+            // Assume the window client size as the default back 
+            // buffer resolution in the landscape orientation.
+            var clientBounds = _game.Window.ClientBounds;
+            if (clientBounds.Width >= clientBounds.Height)
+            {
+                _preferredBackBufferWidth = clientBounds.Width;
+                _preferredBackBufferHeight = clientBounds.Height;
+            }
+            else
+            {
+                _preferredBackBufferWidth = clientBounds.Height;
+                _preferredBackBufferHeight = clientBounds.Width;
+            }
+
+            // Default to windowed mode... this is ignored on platforms that don't support it.
+            _wantFullScreen = false;
+
+            // XNA would read this from the manifest, but it would always default
+            // to reach unless changed.  So lets mimic that without the manifest bit.
+            GraphicsProfile = GraphicsProfile.Reach;
+
+            // Let the plaform optionally overload construction defaults.
+            PlatformConstruct();
+
+            if (_game.Services.GetService(typeof(IGraphicsDeviceManager)) != null)
+                throw new ArgumentException("A graphics device manager is already registered.  The graphics device manager cannot be changed once it is set.");
+            _game.graphicsDeviceManager = this;
+
+            _game.Services.AddService(typeof(IGraphicsDeviceManager), this);
+            _game.Services.AddService(typeof(IGraphicsDeviceService), this);
+        }
+
+        ~GraphicsDeviceManager()
+        {
+            Dispose(false);
+        }
+
+        private void CreateDevice()
+        {
+            if (_graphicsDevice != null)
+                return;
+
+            try
+            {
+                if (!_initialized)
+                    Initialize();
+
+                var gdi = DoPreparingDeviceSettings();
+                CreateDevice(gdi);
+            }
+            catch (NoSuitableGraphicsDeviceException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                throw new NoSuitableGraphicsDeviceException("Failed to create graphics device!", ex);
+            }
+        }
+
+        private void CreateDevice(GraphicsDeviceInformation gdi)
+        {
+            if (_graphicsDevice != null)
+                return;
+
+            _graphicsDevice = new GraphicsDevice(gdi);
+            _shouldApplyChanges = false;
+
+            // hook up reset events
+            GraphicsDevice.DeviceReset     += (sender, args) => OnDeviceReset(args);
+            GraphicsDevice.DeviceResetting += (sender, args) => OnDeviceResetting(args);
+
+            // update the touchpanel display size when the graphicsdevice is reset
+            _graphicsDevice.DeviceReset += UpdateTouchPanel;
+            _graphicsDevice.PresentationChanged += OnPresentationChanged;
+
+            OnDeviceCreated(EventArgs.Empty);
+        }
+
+        void IGraphicsDeviceManager.CreateDevice()
+        {
+            CreateDevice();
+        }
+
+        public bool BeginDraw()
+        {
+            if (_graphicsDevice == null)
+                return false;
+
+            _drawBegun = true;
+            return true;
+        }
+
+        public void EndDraw()
+        {
+            if (_graphicsDevice != null && _drawBegun)
+            {
+                _drawBegun = false;
+                _graphicsDevice.Present();
+            }
+        }
+
+        #region IGraphicsDeviceService Members
+
+        public event EventHandler<EventArgs> DeviceCreated;
+        public event EventHandler<EventArgs> DeviceDisposing;
+        public event EventHandler<EventArgs> DeviceReset;
+        public event EventHandler<EventArgs> DeviceResetting;
+        public event EventHandler<PreparingDeviceSettingsEventArgs> PreparingDeviceSettings;
+        public event EventHandler<EventArgs> Disposed;
+
+        protected void OnDeviceDisposing(EventArgs e)
+        {
+            EventHelpers.Raise(this, DeviceDisposing, e);
+        }
+
+        protected void OnDeviceResetting(EventArgs e)
+        {
+            EventHelpers.Raise(this, DeviceResetting, e);
+        }
+
+        internal void OnDeviceReset(EventArgs e)
+        {
+            EventHelpers.Raise(this, DeviceReset, e);
+        }
+
+        internal void OnDeviceCreated(EventArgs e)
+        {
+            EventHelpers.Raise(this, DeviceCreated, e);
+        }
+
+        /// <summary>
+        /// This populates a GraphicsDeviceInformation instance and invokes PreparingDeviceSettings to
+        /// allow users to change the settings. Then returns that GraphicsDeviceInformation.
+        /// Throws NullReferenceException if users set GraphicsDeviceInformation.PresentationParameters to null.
+        /// </summary>
+        private GraphicsDeviceInformation DoPreparingDeviceSettings()
+        {
+            var gdi = new GraphicsDeviceInformation();
+            PrepareGraphicsDeviceInformation(gdi);
+            var preparingDeviceSettingsHandler = PreparingDeviceSettings;
+
+            if (preparingDeviceSettingsHandler != null)
+            {
+                // this allows users to overwrite settings through the argument
+                var args = new PreparingDeviceSettingsEventArgs(gdi);
+                preparingDeviceSettingsHandler(this, args);
+
+                if (gdi.PresentationParameters == null || gdi.Adapter == null)
+                    throw new NullReferenceException("Members should not be set to null in PreparingDeviceSettingsEventArgs");
+            }
+
+            return gdi;
+        }
+
+        #endregion
+
+        #region IDisposable Members
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    if (_graphicsDevice != null)
+                    {
+                        _graphicsDevice.Dispose();
+                        _graphicsDevice = null;
+                    }
+                }
+                _disposed = true;
+                EventHelpers.Raise(this, Disposed, EventArgs.Empty);
+            }
+        }
+
+        #endregion
+
+        partial void PlatformApplyChanges();
+
+        partial void PlatformPreparePresentationParameters(PresentationParameters presentationParameters);
+
+        private void PreparePresentationParameters(PresentationParameters presentationParameters)
+        {
+            presentationParameters.BackBufferFormat = _preferredBackBufferFormat;
+            presentationParameters.BackBufferWidth = _preferredBackBufferWidth;
+            presentationParameters.BackBufferHeight = _preferredBackBufferHeight;
+            presentationParameters.DepthStencilFormat = _preferredDepthStencilFormat;
+            presentationParameters.IsFullScreen = _wantFullScreen;
+            presentationParameters.HardwareModeSwitch = _hardwareModeSwitch;
+            presentationParameters.PresentationInterval = _synchronizedWithVerticalRetrace ? PresentInterval.One : PresentInterval.Immediate;
+            presentationParameters.DisplayOrientation = _game.Window.CurrentOrientation;
+            presentationParameters.DeviceWindowHandle = _game.Window.Handle;
+
+            if (_preferMultiSampling)
+            {
+                // always initialize MultiSampleCount to the maximum, if users want to overwrite
+                // this they have to respond to the PreparingDeviceSettingsEvent and modify
+                // args.GraphicsDeviceInformation.PresentationParameters.MultiSampleCount
+                presentationParameters.MultiSampleCount = GraphicsDevice != null
+                    ? GraphicsDevice.GraphicsCapabilities.MaxMultiSampleCount
+                    : 32;
+            }
+            else
+            {
+                presentationParameters.MultiSampleCount = 0;
+            }
+
+            PlatformPreparePresentationParameters(presentationParameters);
+        }
+
+        private void PrepareGraphicsDeviceInformation(GraphicsDeviceInformation gdi)
+        {
+            gdi.Adapter = GraphicsAdapter.DefaultAdapter;
+            gdi.GraphicsProfile = GraphicsProfile;
+            var pp = new PresentationParameters();
+            PreparePresentationParameters(pp);
+            gdi.PresentationParameters = pp;
+        }
+
+        /// <summary>
+        /// Applies any pending property changes to the graphics device.
+        /// </summary>
+        public void ApplyChanges()
+        {
+            // If the device hasn't been created then create it now.
+            if (_graphicsDevice == null)
+                CreateDevice();
+
+            if (!_shouldApplyChanges)
+                return;
+
+            _shouldApplyChanges = false;
+
+            _game.Window.SetSupportedOrientations(_supportedOrientations);
+
+            // Allow for optional platform specific behavior.
+            PlatformApplyChanges();
+
+            // populates a gdi with settings in this gdm and allows users to override them with
+            // PrepareDeviceSettings event this information should be applied to the GraphicsDevice
+            var gdi = DoPreparingDeviceSettings();
+
+            if (gdi.GraphicsProfile != GraphicsDevice.GraphicsProfile)
+            {
+                // if the GraphicsProfile changed we need to create a new GraphicsDevice
+                DisposeGraphicsDevice();
+                CreateDevice(gdi);
+                return;
+            }
+
+            GraphicsDevice.Reset(gdi.PresentationParameters);
+        }
+
+        private void DisposeGraphicsDevice()
+        {
+            _graphicsDevice.Dispose();
+            EventHelpers.Raise(this, DeviceDisposing, EventArgs.Empty);
+            _graphicsDevice = null;
+        }
+
+        partial void PlatformInitialize(PresentationParameters presentationParameters);
+
+        private void Initialize()
+        {
+            _game.Window.SetSupportedOrientations(_supportedOrientations);
+
+            var presentationParameters = new PresentationParameters();
+            PreparePresentationParameters(presentationParameters);
+
+            // Allow for any per-platform changes to the presentation.
+            PlatformInitialize(presentationParameters);
+
+            _initialized = true;
+        }
+
+        private void UpdateTouchPanel(object sender, EventArgs eventArgs)
+        {
+            TouchPanel.DisplayWidth = _graphicsDevice.PresentationParameters.BackBufferWidth;
+            TouchPanel.DisplayHeight = _graphicsDevice.PresentationParameters.BackBufferHeight;
+            TouchPanel.DisplayOrientation = _graphicsDevice.PresentationParameters.DisplayOrientation;
+        }
+
+        /// <summary>
+        /// Toggles between windowed and fullscreen modes.
+        /// </summary>
+        /// <remarks>
+        /// Note that on platforms that do not support windowed modes this has no affect.
+        /// </remarks>
+        public void ToggleFullScreen()
+        {
+            IsFullScreen = !IsFullScreen;
+            ApplyChanges();
+        }
+
+        private void OnPresentationChanged(object sender, PresentationEventArgs args)
+        {
+            _game.Platform.OnPresentationChanged(args.PresentationParameters);
+        }
+
+        /// <summary>
+        /// The profile which determines the graphics feature level.
+        /// </summary>
+        public GraphicsProfile GraphicsProfile
+        {
+            get
+            {
+                return _graphicsProfile;
+            }
+            set
+            {
+                _shouldApplyChanges = true;
+                _graphicsProfile = value;
+            }
+        }
+
+        /// <summary>
+        /// Returns the graphics device for this manager.
+        /// </summary>
+        public GraphicsDevice GraphicsDevice
+        {
+            get
+            {
+                return _graphicsDevice;
+            }
+        }
+
+        /// <summary>
+        /// Indicates the desire to switch into fullscreen mode.
+        /// </summary>
+        /// <remarks>
+        /// When called at startup this will automatically set fullscreen mode during initialization.  If
+        /// set after startup you must call ApplyChanges() for the fullscreen mode to be changed.
+        /// Note that for some platforms that do not support windowed modes this property has no affect.
+        /// </remarks>
+        public bool IsFullScreen
+        {
+            get { return _wantFullScreen; }
+            set
+            {
+                _shouldApplyChanges = true;
+                _wantFullScreen = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the boolean which defines how window switches from windowed to fullscreen state.
+        /// "Hard" mode(true) is slow to switch, but more effecient for performance, while "soft" mode(false) is vice versa.
+        /// The default value is <c>true</c>.
+        /// </summary>
+        public bool HardwareModeSwitch
+        {
+            get { return _hardwareModeSwitch;}
+            set
+            {
+                _shouldApplyChanges = true;
+                _hardwareModeSwitch = value;
+            }
+        }
+
+        /// <summary>
+        /// Indicates the desire for a multisampled back buffer.
+        /// </summary>
+        /// <remarks>
+        /// When called at startup this will automatically set the MSAA mode during initialization.  If
+        /// set after startup you must call ApplyChanges() for the MSAA mode to be changed.
+        /// </remarks>
+        public bool PreferMultiSampling
+        {
+            get
+            {
+                return _preferMultiSampling;
+            }
+            set
+            {
+                _shouldApplyChanges = true;
+                _preferMultiSampling = value;
+            }
+        }
+
+        /// <summary>
+        /// Indicates the desired back buffer color format.
+        /// </summary>
+        /// <remarks>
+        /// When called at startup this will automatically set the format during initialization.  If
+        /// set after startup you must call ApplyChanges() for the format to be changed.
+        /// </remarks>
+        public SurfaceFormat PreferredBackBufferFormat
+        {
+            get
+            {
+                return _preferredBackBufferFormat;
+            }
+            set
+            {
+                _shouldApplyChanges = true;
+                _preferredBackBufferFormat = value;
+            }
+        }
+
+        /// <summary>
+        /// Indicates the desired back buffer height in pixels.
+        /// </summary>
+        /// <remarks>
+        /// When called at startup this will automatically set the height during initialization.  If
+        /// set after startup you must call ApplyChanges() for the height to be changed.
+        /// </remarks>
+        public int PreferredBackBufferHeight
+        {
+            get
+            {
+                return _preferredBackBufferHeight;
+            }
+            set
+            {
+                _shouldApplyChanges = true;
+                _preferredBackBufferHeight = value;
+            }
+        }
+
+        /// <summary>
+        /// Indicates the desired back buffer width in pixels.
+        /// </summary>
+        /// <remarks>
+        /// When called at startup this will automatically set the width during initialization.  If
+        /// set after startup you must call ApplyChanges() for the width to be changed.
+        /// </remarks>
+        public int PreferredBackBufferWidth
+        {
+            get
+            {
+                return _preferredBackBufferWidth;
+            }
+            set
+            {
+                _shouldApplyChanges = true;
+                _preferredBackBufferWidth = value;
+            }
+        }
+
+        /// <summary>
+        /// Indicates the desired depth-stencil buffer format.
+        /// </summary>
+        /// <remarks>
+        /// The depth-stencil buffer format defines the scene depth precision and stencil bits available for effects during rendering.
+        /// When called at startup this will automatically set the format during initialization.  If
+        /// set after startup you must call ApplyChanges() for the format to be changed.
+        /// </remarks>
+        public DepthFormat PreferredDepthStencilFormat
+        {
+            get
+            {
+                return _preferredDepthStencilFormat;
+            }
+            set
+            {
+                _shouldApplyChanges = true;
+                _preferredDepthStencilFormat = value;
+            }
+        }
+
+        /// <summary>
+        /// Indicates the desire for vsync when presenting the back buffer.
+        /// </summary>
+        /// <remarks>
+        /// Vsync limits the frame rate of the game to the monitor referesh rate to prevent screen tearing.
+        /// When called at startup this will automatically set the vsync mode during initialization.  If
+        /// set after startup you must call ApplyChanges() for the vsync mode to be changed.
+        /// </remarks>
+        public bool SynchronizeWithVerticalRetrace
+        {
+            get
+            {
+                return _synchronizedWithVerticalRetrace;
+            }
+            set
+            {
+                _shouldApplyChanges = true;
+                _synchronizedWithVerticalRetrace = value;
+            }
+        }
+
+        /// <summary>
+        /// Indicates the desired allowable display orientations when the device is rotated.
+        /// </summary>
+        /// <remarks>
+        /// This property only applies to mobile platforms with automatic display rotation.
+        /// When called at startup this will automatically apply the supported orientations during initialization.  If
+        /// set after startup you must call ApplyChanges() for the supported orientations to be changed.
+        /// </remarks>
+        public DisplayOrientation SupportedOrientations
+        {
+            get
+            {
+                return _supportedOrientations;
+            }
+            set
+            {
+                _shouldApplyChanges = true;
+                _supportedOrientations = value;
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/IDrawable.cs b/MonoGame.Framework/IDrawable.cs
new file mode 100644
index 00000000000..e4aa633965d
--- /dev/null
+++ b/MonoGame.Framework/IDrawable.cs
@@ -0,0 +1,20 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework
+{
+    public interface IDrawable
+    {
+        int DrawOrder { get; }
+        bool Visible { get; }
+		
+		event EventHandler<EventArgs> DrawOrderChanged;
+        event EventHandler<EventArgs> VisibleChanged;
+
+        void Draw(GameTime gameTime);      
+    }
+}
+
diff --git a/MonoGame.Framework/IGameComponent.cs b/MonoGame.Framework/IGameComponent.cs
new file mode 100644
index 00000000000..1cebd150f8f
--- /dev/null
+++ b/MonoGame.Framework/IGameComponent.cs
@@ -0,0 +1,12 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework
+{
+    public interface IGameComponent
+    {
+        void Initialize();
+    }
+}
+
diff --git a/MonoGame.Framework/IGraphicsDeviceManager.cs b/MonoGame.Framework/IGraphicsDeviceManager.cs
new file mode 100644
index 00000000000..ece7b23911f
--- /dev/null
+++ b/MonoGame.Framework/IGraphicsDeviceManager.cs
@@ -0,0 +1,30 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Used by the platform code to control the graphics device.
+    /// </summary>
+    public interface IGraphicsDeviceManager
+    {
+        /// <summary>
+        /// Called at the start of rendering a frame.
+        /// </summary>
+        /// <returns>Returns true if the frame should be rendered.</returns>
+        bool BeginDraw();
+
+        /// <summary>
+        /// Called to create the graphics device.
+        /// </summary>
+        /// <remarks>Does nothing if the graphics device is already created.</remarks>
+        void CreateDevice();
+
+        /// <summary>
+        /// Called after rendering to present the frame to the screen.
+        /// </summary>
+        void EndDraw();
+    }
+}
+
diff --git a/MonoGame.Framework/IPlatformBackButton.cs b/MonoGame.Framework/IPlatformBackButton.cs
new file mode 100644
index 00000000000..92ab240742d
--- /dev/null
+++ b/MonoGame.Framework/IPlatformBackButton.cs
@@ -0,0 +1,17 @@
+using System;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Allows for platform specific handling of the Back button. 
+    /// </summary>
+    /// <seealso cref="http://www.monogame.net/documentation/?page=Platform_Specific_Notes"/>
+    public interface IPlatformBackButton
+    {
+        /// <summary>
+        /// Return true if your game has handled the back button event
+        /// retrn false if you want the operating system to handle it.
+        /// </summary>
+        bool Handled();
+    }
+}
diff --git a/MonoGame.Framework/IUpdateable.cs b/MonoGame.Framework/IUpdateable.cs
new file mode 100644
index 00000000000..6af80b7f6f0
--- /dev/null
+++ b/MonoGame.Framework/IUpdateable.cs
@@ -0,0 +1,27 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework
+{
+	public interface IUpdateable
+	{
+		#region Methods
+		void Update(GameTime gameTime);
+		#endregion
+		
+		#region Events
+		event EventHandler<EventArgs> EnabledChanged;
+		
+		event EventHandler<EventArgs> UpdateOrderChanged;
+		#endregion
+	
+		#region Properties
+		bool Enabled { get; }
+		
+		int UpdateOrder { get; }
+		#endregion
+	}
+}
diff --git a/MonoGame.Framework/Input/ButtonState.cs b/MonoGame.Framework/Input/ButtonState.cs
new file mode 100644
index 00000000000..e6065687cfa
--- /dev/null
+++ b/MonoGame.Framework/Input/ButtonState.cs
@@ -0,0 +1,22 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Defines a button state for buttons of mouse, gamepad or joystick.
+    /// </summary>
+    public enum ButtonState
+    {
+        /// <summary>
+        /// The button is released.
+        /// </summary>
+        Released,
+
+        /// <summary>
+        /// The button is pressed.
+        /// </summary>
+        Pressed
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Input/Buttons.cs b/MonoGame.Framework/Input/Buttons.cs
new file mode 100644
index 00000000000..6d2506abb3c
--- /dev/null
+++ b/MonoGame.Framework/Input/Buttons.cs
@@ -0,0 +1,140 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Defines the buttons on gamepad.
+    /// </summary>
+    [Flags]
+    public enum Buttons
+    {
+        /// <summary>
+        /// Directional pad up.
+        /// </summary>
+        DPadUp = 1,
+
+        /// <summary>
+        /// Directional pad down.
+        /// </summary>
+        DPadDown = 2,
+
+        /// <summary>
+        /// Directional pad left.
+        /// </summary>
+        DPadLeft = 4,
+
+        /// <summary>
+        /// Directional pad right.
+        /// </summary>
+        DPadRight = 8,
+
+        /// <summary>
+        /// START button.
+        /// </summary>
+        Start = 16,
+      
+        /// <summary>
+        /// BACK button.
+        /// </summary>
+        Back = 32,
+
+        /// <summary>
+        /// Left stick button (pressing the left stick).
+        /// </summary>
+        LeftStick = 64,
+
+        /// <summary>
+        /// Right stick button (pressing the right stick).
+        /// </summary>
+        RightStick = 128,
+
+        /// <summary>
+        /// Left bumper (shoulder) button.
+        /// </summary>
+        LeftShoulder = 256,
+
+        /// <summary>
+        /// Right bumper (shoulder) button.
+        /// </summary>
+        RightShoulder = 512,
+
+        /// <summary>
+        /// Big button.
+        /// </summary>    
+        BigButton = 2048,
+       
+        /// <summary>
+        /// A button.
+        /// </summary>
+        A = 4096,
+
+        /// <summary>
+        /// B button.
+        /// </summary>
+        B = 8192,
+
+        /// <summary>
+        /// X button.
+        /// </summary>
+        X = 16384,
+
+        /// <summary>
+        /// Y button.
+        /// </summary>
+        Y = 32768,    
+
+        /// <summary>
+        /// Left stick is towards the left.
+        /// </summary>
+        LeftThumbstickLeft = 2097152,
+
+        /// <summary>
+        /// Right trigger.
+        /// </summary>
+        RightTrigger = 4194304,
+
+        /// <summary>
+        /// Left trigger.
+        /// </summary>
+        LeftTrigger = 8388608,
+
+        /// <summary>
+        /// Right stick is towards up.
+        /// </summary>   
+        RightThumbstickUp = 16777216,
+
+        /// <summary>
+        /// Right stick is towards down.
+        /// </summary>   
+        RightThumbstickDown = 33554432,
+
+        /// <summary>
+        /// Right stick is towards the right.
+        /// </summary>
+        RightThumbstickRight = 67108864,
+
+        /// <summary>
+        /// Right stick is towards the left.
+        /// </summary>
+        RightThumbstickLeft = 134217728,
+
+        /// <summary>
+        /// Left stick is towards up.
+        /// </summary>  
+        LeftThumbstickUp = 268435456,
+
+        /// <summary>
+        /// Left stick is towards down.
+        /// </summary>  
+        LeftThumbstickDown = 536870912,
+
+        /// <summary>
+        /// Left stick is towards the right.
+        /// </summary>
+        LeftThumbstickRight = 1073741824
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePad.Android.cs b/MonoGame.Framework/Input/GamePad.Android.cs
new file mode 100644
index 00000000000..2b293146313
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePad.Android.cs
@@ -0,0 +1,356 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using Android.Views;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    internal class AndroidGamePad
+    {
+        public InputDevice _device;
+        public int _deviceId;
+        public string _descriptor;
+        public bool _isConnected;
+        public bool DPadButtons;
+
+        public Buttons _buttons;
+        public float _leftTrigger, _rightTrigger;
+        public Vector2 _leftStick, _rightStick;
+
+        public readonly GamePadCapabilities _capabilities;
+
+        public AndroidGamePad(InputDevice device)
+        {
+            _device = device;
+            _deviceId = device.Id;
+            _descriptor = device.Descriptor;
+            _isConnected = true;
+
+            _capabilities = CapabilitiesOfDevice(device);
+        }
+
+        private static GamePadCapabilities CapabilitiesOfDevice(InputDevice device)
+        {
+            var capabilities = new GamePadCapabilities();
+            capabilities.IsConnected = true;
+            capabilities.GamePadType = GamePadType.GamePad;
+            capabilities.HasLeftVibrationMotor = capabilities.HasRightVibrationMotor = device.Vibrator.HasVibrator;
+
+            // build out supported inputs from what the gamepad exposes
+            int[] keyMap = new int[16];
+            keyMap[0] = (int)Keycode.ButtonA;
+            keyMap[1] = (int)Keycode.ButtonB;
+            keyMap[2] = (int)Keycode.ButtonX;
+            keyMap[3] = (int)Keycode.ButtonY;
+
+            keyMap[4] = (int)Keycode.ButtonThumbl;
+            keyMap[5] = (int)Keycode.ButtonThumbr;
+
+            keyMap[6] = (int)Keycode.ButtonL1;
+            keyMap[7] = (int)Keycode.ButtonR1;
+            keyMap[8] = (int)Keycode.ButtonL2;
+            keyMap[9] = (int)Keycode.ButtonR2;
+
+            keyMap[10] = (int)Keycode.DpadDown;
+            keyMap[11] = (int)Keycode.DpadLeft;
+            keyMap[12] = (int)Keycode.DpadRight;
+            keyMap[13] = (int)Keycode.DpadUp;
+
+            keyMap[14] = (int)Keycode.ButtonStart;
+            keyMap[15] = (int)Keycode.Back;
+
+            bool[] hasMap = new bool[16];
+            // get a bool[] with indices matching the keyMap
+            hasMap = device.HasKeys(keyMap);
+
+            capabilities.HasAButton = hasMap[0];
+            capabilities.HasBButton = hasMap[1];
+            capabilities.HasXButton = hasMap[2];
+            capabilities.HasYButton = hasMap[3];
+
+            // we only check for the thumb button to see if we have 2 thumbsticks
+            // if ever a controller doesn't support buttons on the thumbsticks,
+            // this will need fixing
+            capabilities.HasLeftXThumbStick = hasMap[4];
+            capabilities.HasLeftYThumbStick = hasMap[4];
+            capabilities.HasRightXThumbStick = hasMap[5];
+            capabilities.HasRightYThumbStick = hasMap[5];
+
+            capabilities.HasLeftShoulderButton = hasMap[6];
+            capabilities.HasRightShoulderButton = hasMap[7];
+            capabilities.HasLeftTrigger = hasMap[8];
+            capabilities.HasRightTrigger = hasMap[9];
+
+            capabilities.HasDPadDownButton = hasMap[10];
+            capabilities.HasDPadLeftButton = hasMap[11];
+            capabilities.HasDPadRightButton = hasMap[12];
+            capabilities.HasDPadUpButton = hasMap[13];
+
+            capabilities.HasStartButton = hasMap[14];
+            capabilities.HasBackButton = hasMap[15];
+
+            return capabilities;
+        }
+    }
+
+
+    static partial class GamePad
+    {
+        // we will support up to 4 local controllers
+        private static readonly AndroidGamePad[] GamePads = new AndroidGamePad[4];
+        // support the back button when we don't have a gamepad connected
+        internal static bool Back;
+
+        private static int PlatformGetMaxNumberOfGamePads()
+        {
+            return 4;
+        }
+
+        private static GamePadCapabilities PlatformGetCapabilities(int index)
+        {
+            var gamePad = GamePads[index];
+            if (gamePad != null)
+                return gamePad._capabilities;
+
+            // we need to add the default "no gamepad connected but the user hit back"
+            // behaviour here
+            GamePadCapabilities capabilities = new GamePadCapabilities();
+            capabilities.IsConnected = false;
+            capabilities.HasBackButton = true;
+
+            return capabilities;
+        }
+
+        private static GamePadState PlatformGetState(int index, GamePadDeadZone leftDeadZoneMode, GamePadDeadZone rightDeadZoneMode)
+        {
+            var gamePad = GamePads[index];
+            GamePadState state = GamePadState.Default;
+            if (gamePad != null && gamePad._isConnected)
+            {
+                // Check if the device was disconnected
+                var dvc = InputDevice.GetDevice(gamePad._deviceId);
+                if (dvc == null)
+                {
+                    Android.Util.Log.Debug("MonoGame", "Detected controller disconnect [" + index + "] ");
+                    gamePad._isConnected = false;
+                    return state;
+                }
+
+                GamePadThumbSticks thumbSticks = new GamePadThumbSticks(gamePad._leftStick, gamePad._rightStick, leftDeadZoneMode, rightDeadZoneMode);
+
+                state = new GamePadState(
+                    thumbSticks,
+                    new GamePadTriggers(gamePad._leftTrigger, gamePad._rightTrigger),
+                    new GamePadButtons(gamePad._buttons),
+                    new GamePadDPad(gamePad._buttons));
+            }
+            // we need to add the default "no gamepad connected but the user hit back"
+            // behaviour here
+            else {
+                if (index == 0 && Back)
+                {
+                    // Consume state
+                    Back = false;
+                    state = new GamePadState(new GamePadThumbSticks(), new GamePadTriggers(), new GamePadButtons(Buttons.Back), new GamePadDPad());
+                    state.IsConnected = false;
+                }
+                else
+                    state = new GamePadState();
+            }
+
+            return state;
+        }
+
+        private static bool PlatformSetVibration(int index, float leftMotor, float rightMotor)
+        {
+            var gamePad = GamePads[index];
+            if (gamePad == null)
+                return false;
+
+            var vibrator = gamePad._device.Vibrator;
+            if (!vibrator.HasVibrator)
+                return false;
+            vibrator.Vibrate(500);
+            return true;
+        }
+
+        internal static AndroidGamePad GetGamePad(InputDevice device)
+        {
+            if (device == null || (device.Sources & InputSourceType.Gamepad) != InputSourceType.Gamepad)
+                return null;
+
+            int firstDisconnectedPadId = -1;
+            for (int i = 0; i < GamePads.Length; i++)
+            {
+                var pad = GamePads[i];
+                if (pad != null && pad._isConnected && pad._deviceId == device.Id)
+                {
+                    return pad;
+                }
+                else if (pad != null && !pad._isConnected && pad._descriptor == device.Descriptor)
+                {
+                    Android.Util.Log.Debug("MonoGame", "Found previous controller [" + i + "] " + device.Name);
+                    pad._deviceId = device.Id;
+                    pad._isConnected = true;
+                    return pad;
+                }
+                else if (pad == null)
+                {
+                    Android.Util.Log.Debug("MonoGame", "Found new controller [" + i + "] " + device.Name);
+                    pad = new AndroidGamePad(device);
+                    GamePads[i] = pad;
+                    return pad;
+                }
+                else if (!pad._isConnected && firstDisconnectedPadId < 0)
+                {
+                    firstDisconnectedPadId = i;
+                }
+            }
+
+            // If we get here, we failed to find a game pad or an empty slot to create one.
+            // If we're holding onto a disconnected pad, overwrite it with this one
+            if (firstDisconnectedPadId >= 0)
+            {
+                Android.Util.Log.Debug("MonoGame", "Found new controller in place of disconnected controller [" + firstDisconnectedPadId + "] " + device.Name);
+                var pad = new AndroidGamePad(device);
+                GamePads[firstDisconnectedPadId] = pad;
+                return pad;
+            }
+
+            // All pad slots are taken so ignore further devices.
+            return null;
+        }
+
+        internal static bool OnKeyDown(Keycode keyCode, KeyEvent e)
+        {
+            var gamePad = GetGamePad(e.Device);
+            if (gamePad == null)
+                return false;
+
+            gamePad.DPadButtons |= e.KeyCode == Keycode.DpadLeft ||
+                                   e.KeyCode == Keycode.DpadUp || 
+                                   e.KeyCode == Keycode.DpadRight || 
+                                   e.KeyCode == Keycode.DpadDown;
+            gamePad._buttons |= ButtonForKeyCode(keyCode);
+
+            return true;
+        }
+
+        internal static bool OnKeyUp(Keycode keyCode, KeyEvent e)
+        {
+            var gamePad = GetGamePad(e.Device);
+            if (gamePad == null)
+                return false;
+
+            gamePad._buttons &= ~ButtonForKeyCode(keyCode);
+            return true;
+        }
+
+        internal static bool OnGenericMotionEvent(MotionEvent e)
+        {
+            var gamePad = GetGamePad(e.Device);
+            if (gamePad == null)
+                return false;
+
+            if (e.Action != MotionEventActions.Move)
+                return false;
+
+            gamePad._leftStick = new Vector2(e.GetAxisValue(Axis.X), -e.GetAxisValue(Axis.Y));
+            gamePad._rightStick = new Vector2(e.GetAxisValue(Axis.Z), -e.GetAxisValue(Axis.Rz));
+            gamePad._leftTrigger = e.GetAxisValue(Axis.Ltrigger);
+            gamePad._rightTrigger = e.GetAxisValue(Axis.Rtrigger);
+
+            if(!gamePad.DPadButtons)
+            {
+                if(e.GetAxisValue(Axis.HatX) < 0)
+                {
+                    gamePad._buttons |= Buttons.DPadLeft;
+                    gamePad._buttons &= ~Buttons.DPadRight;
+                }
+                else if(e.GetAxisValue(Axis.HatX) > 0)
+                {
+                    gamePad._buttons &= ~Buttons.DPadLeft;
+                    gamePad._buttons |= Buttons.DPadRight;
+                }
+                else
+                {
+                    gamePad._buttons &= ~Buttons.DPadLeft;
+                    gamePad._buttons &= ~Buttons.DPadRight;
+                }
+
+                if(e.GetAxisValue(Axis.HatY) < 0)
+                {
+                    gamePad._buttons |= Buttons.DPadUp;
+                    gamePad._buttons &= ~Buttons.DPadDown;
+                }
+                else if(e.GetAxisValue(Axis.HatY) > 0)
+                {
+                    gamePad._buttons &= ~Buttons.DPadUp;
+                    gamePad._buttons |= Buttons.DPadDown;
+                }
+                else
+                {
+                    gamePad._buttons &= ~Buttons.DPadUp;
+                    gamePad._buttons &= ~Buttons.DPadDown;
+                }
+            }
+
+            return true;
+        }
+
+        private static Buttons ButtonForKeyCode(Keycode keyCode)
+        {
+            switch (keyCode)
+            {
+                case Keycode.ButtonA:
+                    return Buttons.A;
+                case Keycode.ButtonX:
+                    return Buttons.X;
+                case Keycode.ButtonY:
+                    return Buttons.Y;
+                case Keycode.ButtonB:
+                    return Buttons.B;
+
+                case Keycode.ButtonL1:
+                    return Buttons.LeftShoulder;
+                case Keycode.ButtonL2:
+                    return Buttons.LeftTrigger;
+                case Keycode.ButtonR1:
+                    return Buttons.RightShoulder;
+                case Keycode.ButtonR2:
+                    return Buttons.RightTrigger;
+
+                case Keycode.ButtonThumbl:
+                    return Buttons.LeftStick;
+                case Keycode.ButtonThumbr:
+                    return Buttons.RightStick;
+
+                case Keycode.DpadUp:
+                    return Buttons.DPadUp;
+                case Keycode.DpadDown:
+                    return Buttons.DPadDown;
+                case Keycode.DpadLeft:
+                    return Buttons.DPadLeft;
+                case Keycode.DpadRight:
+                    return Buttons.DPadRight;
+
+                case Keycode.ButtonStart:
+                    return Buttons.Start;
+                case Keycode.Back:
+                    return Buttons.Back;
+            }
+
+            return 0;
+        }
+
+        internal static void Initialize()
+        {
+            //Iterate and 'connect' any detected gamepads
+            foreach (var deviceId in InputDevice.GetDeviceIds())
+            {
+                GetGamePad(InputDevice.GetDevice(deviceId));
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePad.IOS.cs b/MonoGame.Framework/Input/GamePad.IOS.cs
new file mode 100644
index 00000000000..6da1ec24633
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePad.IOS.cs
@@ -0,0 +1,229 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using GameController;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    static partial class GamePad
+    {
+        private static int PlatformGetMaxNumberOfGamePads()
+        {
+            return 4;
+        }
+
+        static bool IndexIsUsed(GCControllerPlayerIndex index)
+        {
+            foreach (var ctrl in GCController.Controllers)
+                if (ctrl.PlayerIndex == (int)index) return true;
+
+            return false;
+        }
+
+        static void AssingIndex(GCControllerPlayerIndex index)
+        {
+            if (IndexIsUsed(index))
+                return;
+            foreach (var controller in GCController.Controllers)
+            {
+                if (controller.PlayerIndex == (int)index)
+                    break;
+                if (controller.PlayerIndex == (int)GCControllerPlayerIndex.Unset)
+                {
+                    controller.PlayerIndex = (int)index;
+                    break;
+                }
+            }
+        }
+
+        private static GamePadCapabilities PlatformGetCapabilities(int index)
+        {
+            var ind = (GCControllerPlayerIndex)index;
+
+            AssingIndex(ind);
+
+            foreach (var controller in GCController.Controllers)
+            {
+                if (controller == null)
+                    continue;
+                if (controller.PlayerIndex == (int)ind)
+                    return GetCapabilities(controller);
+            }
+            return new GamePadCapabilities { IsConnected = false };
+        }
+
+        private static GamePadCapabilities GetCapabilities(GCController controller)
+        {
+            //All iOS controllers have these basics
+            var capabilities = new GamePadCapabilities()
+            {
+                IsConnected = false,
+                GamePadType = GamePadType.GamePad,
+            };
+            if (controller.ExtendedGamepad != null)
+            {
+                capabilities.HasAButton = true;
+                capabilities.HasBButton = true;
+                capabilities.HasXButton = true;
+                capabilities.HasYButton = true;
+                capabilities.HasBackButton = true;
+                capabilities.HasDPadUpButton = true;
+                capabilities.HasDPadDownButton = true;
+                capabilities.HasDPadLeftButton = true;
+                capabilities.HasDPadRightButton = true;
+                capabilities.HasLeftShoulderButton = true;
+                capabilities.HasRightShoulderButton = true;
+                capabilities.HasLeftTrigger = true;
+                capabilities.HasRightTrigger = true;
+                capabilities.HasLeftXThumbStick = true;
+                capabilities.HasLeftYThumbStick = true;
+                capabilities.HasRightXThumbStick = true;
+                capabilities.HasRightYThumbStick = true;
+            }
+            else if (controller.Gamepad != null)
+            {
+                capabilities.HasAButton = true;
+                capabilities.HasBButton = true;
+                capabilities.HasXButton = true;
+                capabilities.HasYButton = true;
+                capabilities.HasBackButton = true;
+                capabilities.HasDPadUpButton = true;
+                capabilities.HasDPadDownButton = true;
+                capabilities.HasDPadLeftButton = true;
+                capabilities.HasDPadRightButton = true;
+                capabilities.HasLeftShoulderButton = true;
+                capabilities.HasRightShoulderButton = true;
+            }
+            return capabilities;
+        }
+
+        private static GamePadState PlatformGetState(int index, GamePadDeadZone leftDeadZoneMode, GamePadDeadZone rightDeadZoneMode)
+        {
+            var ind = (GCControllerPlayerIndex)index;
+
+
+            Buttons buttons = 0;
+            bool connected = false;
+            ButtonState Up = ButtonState.Released;
+            ButtonState Down = ButtonState.Released;
+            ButtonState Left = ButtonState.Released;
+            ButtonState Right = ButtonState.Released;
+
+            Vector2 leftThumbStickPosition = Vector2.Zero;
+            Vector2 rightThumbStickPosition = Vector2.Zero;
+
+            float leftTriggerValue = 0;
+            float rightTriggerValue = 0;
+
+            AssingIndex(ind);
+
+            foreach (var controller in GCController.Controllers)
+            {
+
+                if (controller == null)
+                    continue;
+
+                if (controller.PlayerIndex != (int)ind)
+                    continue;
+
+                connected = true;
+
+                if (controller.ExtendedGamepad != null)
+                {
+                    if (controller.ExtendedGamepad.ButtonA.IsPressed)
+                        buttons |= Buttons.A;
+                    if (controller.ExtendedGamepad.ButtonB.IsPressed)
+                        buttons |= Buttons.B;
+                    if (controller.ExtendedGamepad.ButtonX.IsPressed)
+                        buttons |= Buttons.X;
+                    if (controller.ExtendedGamepad.ButtonY.IsPressed)
+                        buttons |= Buttons.Y;
+
+                    if (controller.ExtendedGamepad.LeftShoulder.IsPressed)
+                        buttons |= Buttons.LeftShoulder;
+                    if (controller.ExtendedGamepad.RightShoulder.IsPressed)
+                        buttons |= Buttons.RightShoulder;
+
+                    if (controller.ExtendedGamepad.LeftTrigger.IsPressed)
+                        buttons |= Buttons.LeftTrigger;
+                    if (controller.ExtendedGamepad.RightTrigger.IsPressed)
+                        buttons |= Buttons.RightTrigger;
+
+                    if (controller.ExtendedGamepad.DPad.Up.IsPressed)
+                    {
+                        Up = ButtonState.Pressed;
+                        buttons |= Buttons.DPadUp;
+                    }
+                    if (controller.ExtendedGamepad.DPad.Down.IsPressed)
+                    {
+                        Down = ButtonState.Pressed;
+                        buttons |= Buttons.DPadDown;
+                    }
+                    if (controller.ExtendedGamepad.DPad.Left.IsPressed)
+                    {
+                        Left = ButtonState.Pressed;
+                        buttons |= Buttons.DPadLeft;
+                    }
+                    if (controller.ExtendedGamepad.DPad.Right.IsPressed)
+                    {
+                        Right = ButtonState.Pressed;
+                        buttons |= Buttons.DPadRight;
+                    }
+
+                    leftThumbStickPosition.X = controller.ExtendedGamepad.LeftThumbstick.XAxis.Value;
+                    leftThumbStickPosition.Y = controller.ExtendedGamepad.LeftThumbstick.YAxis.Value;
+                    rightThumbStickPosition.X = controller.ExtendedGamepad.RightThumbstick.XAxis.Value;
+                    rightThumbStickPosition.Y = controller.ExtendedGamepad.RightThumbstick.YAxis.Value;
+                    leftTriggerValue = controller.ExtendedGamepad.LeftTrigger.Value;
+                    rightTriggerValue = controller.ExtendedGamepad.RightTrigger.Value;
+                }
+                else if (controller.Gamepad != null)
+                {
+                    if (controller.Gamepad.ButtonA.IsPressed)
+                        buttons |= Buttons.A;
+                    if (controller.Gamepad.ButtonB.IsPressed)
+                        buttons |= Buttons.B;
+                    if (controller.Gamepad.ButtonX.IsPressed)
+                        buttons |= Buttons.X;
+                    if (controller.Gamepad.ButtonY.IsPressed)
+                        buttons |= Buttons.Y;
+
+                    if (controller.Gamepad.DPad.Up.IsPressed)
+                    {
+                        Up = ButtonState.Pressed;
+                        buttons |= Buttons.DPadUp;
+                    }
+                    if (controller.Gamepad.DPad.Down.IsPressed)
+                    {
+                        Down = ButtonState.Pressed;
+                        buttons |= Buttons.DPadDown;
+                    }
+                    if (controller.Gamepad.DPad.Left.IsPressed)
+                    {
+                        Left = ButtonState.Pressed;
+                        buttons |= Buttons.DPadLeft;
+                    }
+                    if (controller.Gamepad.DPad.Right.IsPressed)
+                    {
+                        Right = ButtonState.Pressed;
+                        buttons |= Buttons.DPadRight;
+                    }
+                }
+            }
+            var state = new GamePadState(
+                new GamePadThumbSticks(leftThumbStickPosition, rightThumbStickPosition, leftDeadZoneMode, rightDeadZoneMode),
+                new GamePadTriggers(leftTriggerValue, rightTriggerValue),
+                new GamePadButtons(buttons),
+                new GamePadDPad(Up, Down, Left, Right));
+            state.IsConnected = connected;
+            return state;
+        }
+
+        private static bool PlatformSetVibration(int index, float leftMotor, float rightMotor)
+        {
+            return false;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePad.SDL.cs b/MonoGame.Framework/Input/GamePad.SDL.cs
new file mode 100644
index 00000000000..d84a98501b3
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePad.SDL.cs
@@ -0,0 +1,309 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    static partial class GamePad
+    {
+        private class GamePadInfo
+        {
+            public IntPtr Device;
+            public IntPtr HapticDevice;
+            public int HapticType;
+        }
+
+        private static readonly Dictionary<int, GamePadInfo> Gamepads = new Dictionary<int, GamePadInfo>();
+
+        private static Sdl.Haptic.Effect _hapticLeftRightEffect = new Sdl.Haptic.Effect
+        {
+            type = Sdl.Haptic.EffectId.LeftRight,
+            leftright = new Sdl.Haptic.LeftRight
+            {
+                Type = Sdl.Haptic.EffectId.LeftRight,
+                Length = Sdl.Haptic.Infinity,
+                LargeMagnitude = ushort.MaxValue,
+                SmallMagnitude = ushort.MaxValue
+            }
+        };
+
+        public static void InitDatabase()
+        {
+            using (var stream = ReflectionHelpers.GetAssembly(typeof(GamePad)).GetManifestResourceStream("gamecontrollerdb.txt"))
+            {
+                if (stream != null)
+                {
+                    using (var reader = new BinaryReader(stream))
+                    {
+                        try
+                        {
+                            var src = Sdl.RwFromMem(reader.ReadBytes((int)stream.Length), (int)stream.Length);
+                            Sdl.GameController.AddMappingFromRw(src, 1);
+                        }
+                        catch { }
+                    }
+                }
+            }
+        }
+
+        internal static void AddDevice(int deviceId)
+        {
+            var gamepad = new GamePadInfo();
+            gamepad.Device = Sdl.GameController.Open(deviceId);
+            gamepad.HapticDevice = Sdl.Haptic.OpenFromJoystick(Sdl.GameController.GetJoystick(gamepad.Device));
+
+            var id = 0;
+            while (Gamepads.ContainsKey(id))
+                id++;
+
+            Gamepads.Add(id, gamepad);
+            
+            if (gamepad.HapticDevice == IntPtr.Zero)
+                return;
+
+            try
+            {
+                if (Sdl.Haptic.EffectSupported(gamepad.HapticDevice, ref _hapticLeftRightEffect) == 1)
+                {
+                    Sdl.Haptic.NewEffect(gamepad.HapticDevice, ref _hapticLeftRightEffect);
+                    gamepad.HapticType = 1;
+                }
+                else if (Sdl.Haptic.RumbleSupported(gamepad.HapticDevice) == 1)
+                {
+                    Sdl.Haptic.RumbleInit(gamepad.HapticDevice);
+                    gamepad.HapticType = 2;
+                }
+                else
+                    Sdl.Haptic.Close(gamepad.HapticDevice);
+            }
+            catch
+            {
+                Sdl.Haptic.Close(gamepad.HapticDevice);
+                gamepad.HapticDevice = IntPtr.Zero;
+                Sdl.ClearError();
+            }
+        }
+
+        internal static void RemoveDevice(int instanceid)
+        {
+            foreach (KeyValuePair<int, GamePadInfo> entry in Gamepads)
+            {
+                if (Sdl.Joystick.InstanceID(Sdl.GameController.GetJoystick(entry.Value.Device)) == instanceid)
+                {
+                    Gamepads.Remove(entry.Key);
+                    DisposeDevice(entry.Value);
+                    break;
+                }
+            }
+        }
+
+        private static void DisposeDevice(GamePadInfo info)
+        {
+            if (info.HapticType > 0)
+                Sdl.Haptic.Close(info.HapticDevice);
+            Sdl.GameController.Close(info.Device);
+        }
+
+        internal static void CloseDevices()
+        {
+            foreach (var entry in Gamepads)
+                DisposeDevice(entry.Value);
+
+            Gamepads.Clear();
+        }
+
+        private static int PlatformGetMaxNumberOfGamePads()
+        {
+            return 16;
+        }
+
+        private static GamePadCapabilities PlatformGetCapabilities(int index)
+        {
+            if (!Gamepads.ContainsKey(index))
+                return new GamePadCapabilities();
+
+            var gamecontroller = Gamepads[index].Device;
+            var caps = new GamePadCapabilities();
+            var mapping = Sdl.GameController.GetMapping(gamecontroller).Split(',');
+
+            caps.IsConnected = true;
+            caps.DisplayName = Sdl.GameController.GetName(gamecontroller);
+            caps.Identifier = Sdl.Joystick.GetGUID(Sdl.GameController.GetJoystick(gamecontroller)).ToString();
+            caps.HasLeftVibrationMotor = caps.HasRightVibrationMotor = (Gamepads[index].HapticType != 0);
+            caps.GamePadType = GamePadType.GamePad;
+
+            foreach (var map in mapping)
+            {
+                var split = map.Split(':');
+                if (split.Length != 2)
+                    continue;
+
+                switch (split[0])
+                {
+                    case "a":
+                        caps.HasAButton = true;
+                        break;
+                    case "b":
+                        caps.HasBButton = true;
+                        break;
+                    case "x":
+                        caps.HasXButton = true;
+                        break;
+                    case "y":
+                        caps.HasYButton = true;
+                        break;
+                    case "back":
+                        caps.HasBackButton = true;
+                        break;
+                    case "guide":
+                        caps.HasBigButton = true;
+                        break;
+                    case "start":
+                        caps.HasStartButton = true;
+                        break;
+                    case "dpleft":
+                        caps.HasDPadLeftButton = true;
+                        break;
+                    case "dpdown":
+                        caps.HasDPadDownButton = true;
+                        break;
+                    case "dpright":
+                        caps.HasDPadRightButton = true;
+                        break;
+                    case "dpup":
+                        caps.HasDPadUpButton = true;
+                        break;
+                    case "leftshoulder":
+                        caps.HasLeftShoulderButton = true;
+                        break;
+                    case "lefttrigger":
+                        caps.HasLeftTrigger = true;
+                        break;
+                    case "rightshoulder":
+                        caps.HasRightShoulderButton = true;
+                        break;
+                    case "righttrigger":
+                        caps.HasRightTrigger = true;
+                        break;
+                    case "leftstick":
+                        caps.HasLeftStickButton = true;
+                        break;
+                    case "rightstick":
+                        caps.HasRightStickButton = true;
+                        break;
+                    case "leftx":
+                        caps.HasLeftXThumbStick = true;
+                        break;
+                    case "lefty":
+                        caps.HasLeftYThumbStick = true;
+                        break;
+                    case "rightx":
+                        caps.HasRightXThumbStick = true;
+                        break;
+                    case "righty":
+                        caps.HasRightYThumbStick = true;
+                        break;
+                }
+            }
+
+            return caps;
+        }
+
+        private static float GetFromSdlAxis(int axis)
+        {
+            // SDL Axis ranges from -32768 to 32767, so we need to divide with different numbers depending on if it's positive
+            if (axis < 0)
+                return axis / 32768f;
+
+            return axis / 32767f;
+        }
+
+        private static GamePadState PlatformGetState(int index, GamePadDeadZone leftDeadZoneMode, GamePadDeadZone rightDeadZoneMode)
+        {
+            if (!Gamepads.ContainsKey(index))
+                return GamePadState.Default;
+
+            var gdevice = Gamepads[index].Device;
+
+            // Y gamepad axis is rotate between SDL and XNA
+            var thumbSticks =
+                new GamePadThumbSticks(
+                    new Vector2(
+                        GetFromSdlAxis(Sdl.GameController.GetAxis(gdevice, Sdl.GameController.Axis.LeftX)),
+                        GetFromSdlAxis(Sdl.GameController.GetAxis(gdevice, Sdl.GameController.Axis.LeftY)) * -1f
+                    ),
+                    new Vector2(
+                        GetFromSdlAxis(Sdl.GameController.GetAxis(gdevice, Sdl.GameController.Axis.RightX)),
+                        GetFromSdlAxis(Sdl.GameController.GetAxis(gdevice, Sdl.GameController.Axis.RightY)) * -1f
+                    ),
+                    leftDeadZoneMode,
+                    rightDeadZoneMode
+                );
+
+            var triggers = new GamePadTriggers(
+                GetFromSdlAxis(Sdl.GameController.GetAxis(gdevice, Sdl.GameController.Axis.TriggerLeft)),
+                GetFromSdlAxis(Sdl.GameController.GetAxis(gdevice, Sdl.GameController.Axis.TriggerRight))
+            );
+
+            var buttons =
+                new GamePadButtons(
+                    ((Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.A) == 1) ? Buttons.A : 0) |
+                    ((Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.B) == 1) ? Buttons.B : 0) |
+                    ((Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.Back) == 1) ? Buttons.Back : 0) |
+                    ((Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.Guide) == 1) ? Buttons.BigButton : 0) |
+                    ((Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.LeftShoulder) == 1) ? Buttons.LeftShoulder : 0) |
+                    ((Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.RightShoulder) == 1) ? Buttons.RightShoulder : 0) |
+                    ((Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.LeftStick) == 1) ? Buttons.LeftStick : 0) |
+                    ((Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.RightStick) == 1) ? Buttons.RightStick : 0) |
+                    ((Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.Start) == 1) ? Buttons.Start : 0) |
+                    ((Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.X) == 1) ? Buttons.X : 0) |
+                    ((Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.Y) == 1) ? Buttons.Y : 0) |
+                    ((triggers.Left > 0f) ? Buttons.LeftTrigger : 0) |
+                    ((triggers.Right > 0f) ? Buttons.RightTrigger : 0)
+                );
+
+            var dPad =
+                new GamePadDPad(
+                    (Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.DpadUp) == 1) ? ButtonState.Pressed : ButtonState.Released,
+                    (Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.DpadDown) == 1) ? ButtonState.Pressed : ButtonState.Released,
+                    (Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.DpadLeft) == 1) ? ButtonState.Pressed : ButtonState.Released,
+                    (Sdl.GameController.GetButton(gdevice, Sdl.GameController.Button.DpadRight) == 1) ? ButtonState.Pressed : ButtonState.Released
+                );
+
+            return new GamePadState(thumbSticks, triggers, buttons, dPad);
+        }
+
+        private static bool PlatformSetVibration(int index, float leftMotor, float rightMotor)
+        {
+            if (!Gamepads.ContainsKey(index))
+                return false;
+
+            var gamepad = Gamepads[index];
+
+            if (gamepad.HapticType == 0)
+                return false;
+
+            if (leftMotor <= 0.0f && rightMotor <= 0.0f)
+                Sdl.Haptic.StopAll(gamepad.HapticDevice);
+            else if (gamepad.HapticType == 1)
+            {
+                _hapticLeftRightEffect.leftright.LargeMagnitude = (ushort)(65535f * leftMotor);
+                _hapticLeftRightEffect.leftright.SmallMagnitude = (ushort)(65535f * rightMotor);
+
+                Sdl.Haptic.UpdateEffect(gamepad.HapticDevice, 0, ref _hapticLeftRightEffect);
+                Sdl.Haptic.RunEffect(gamepad.HapticDevice, 0, 1);
+            }
+            else if (gamepad.HapticType == 2)
+                Sdl.Haptic.RumblePlay(gamepad.HapticDevice, Math.Max(leftMotor, rightMotor), Sdl.Haptic.Infinity);
+
+            return true;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePad.UWP.cs b/MonoGame.Framework/Input/GamePad.UWP.cs
new file mode 100644
index 00000000000..215cb26c95a
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePad.UWP.cs
@@ -0,0 +1,170 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using WGI = Windows.Gaming.Input;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    static partial class GamePad
+    {
+        // Attempts to mimic SharpDX.XInput.Gamepad which defines the trigger threshold as 30 with a range of 0 to 255. 
+        // The trigger here has a range of 0.0 to 1.0. So, 30 / 255 = 0.11765.
+        private const double TriggerThreshold = 0.11765;
+
+        internal static bool Back;
+
+        private static Dictionary<int, WGI.Gamepad> _gamepads;
+
+        static GamePad()
+        {
+            _gamepads = new Dictionary<int, WGI.Gamepad>();
+            var gamepads = WGI.Gamepad.Gamepads;
+            for (int i = 0; i < gamepads.Count; i++)
+                _gamepads[i] = gamepads[i];
+
+            WGI.Gamepad.GamepadAdded += (o, e) =>
+            {
+                var index = 0;
+                while (_gamepads.ContainsKey(index))
+                    index++;
+
+                _gamepads[index] = e;
+            };
+
+            WGI.Gamepad.GamepadRemoved += (o, e) =>
+            {
+                int? key = _gamepads.FirstOrDefault(x => x.Value == e).Key;
+
+                if (key.HasValue)
+                    _gamepads.Remove(key.Value);
+            };
+        }
+
+        private static int PlatformGetMaxNumberOfGamePads()
+        {
+            return 16;
+        }
+
+        private static GamePadCapabilities PlatformGetCapabilities(int index)
+        {
+            if (!_gamepads.ContainsKey(index))
+                return new GamePadCapabilities();
+            
+            var gamepad = _gamepads[index];
+
+            // we can't check gamepad capabilities for most stuff with Windows.Gaming.Input.Gamepad
+            return new GamePadCapabilities
+            {
+                IsConnected = true,
+                GamePadType = GamePadType.GamePad,
+                HasAButton = true,
+                HasBButton = true,
+                HasXButton = true,
+                HasYButton = true,
+                HasBackButton = true,
+                HasStartButton = true,
+                HasDPadDownButton = true,
+                HasDPadLeftButton = true,
+                HasDPadRightButton = true,
+                HasDPadUpButton = true,
+                HasLeftShoulderButton = true,
+                HasRightShoulderButton = true,
+                HasLeftStickButton = true,
+                HasRightStickButton = true,
+                HasLeftTrigger = true,
+                HasRightTrigger = true,
+                HasLeftXThumbStick = true,
+                HasLeftYThumbStick = true,
+                HasRightXThumbStick = true,
+                HasRightYThumbStick = true,
+                HasLeftVibrationMotor = true,
+                HasRightVibrationMotor = true,
+                HasVoiceSupport = (gamepad.Headset != null && !string.IsNullOrEmpty(gamepad.Headset.CaptureDeviceId)),
+                HasBigButton = false //we can't detect the big button from Windows.Gaming.Input.Gamepad, so it's always false
+            };
+        }
+
+        private static GamePadState GetDefaultState()
+        {
+            var state = new GamePadState();
+            state.Buttons = new GamePadButtons(Back ? Buttons.Back : 0);
+            return state;
+        }
+
+        private static GamePadState PlatformGetState(int index, GamePadDeadZone leftDeadZoneMode, GamePadDeadZone rightDeadZoneMode)
+        {
+            if (!_gamepads.ContainsKey(index))
+                return (index == 0 ? GetDefaultState() : GamePadState.Default);
+
+            var state = _gamepads[index].GetCurrentReading();
+
+            var sticks = new GamePadThumbSticks(
+                    new Vector2((float)state.LeftThumbstickX, (float)state.LeftThumbstickY),
+                    new Vector2((float)state.RightThumbstickX, (float)state.RightThumbstickY),
+                    leftDeadZoneMode,
+					rightDeadZoneMode
+                );
+
+            var triggers = new GamePadTriggers(
+                    (float)state.LeftTrigger,
+                    (float)state.RightTrigger
+                );
+
+            Buttons buttonStates =
+                (state.Buttons.HasFlag(WGI.GamepadButtons.A) ? Buttons.A : 0) |
+                (state.Buttons.HasFlag(WGI.GamepadButtons.B) ? Buttons.B : 0) |
+                ((state.Buttons.HasFlag(WGI.GamepadButtons.View) || Back) ? Buttons.Back : 0) |
+                0 | //BigButton is unavailable by Windows.Gaming.Input.Gamepad
+                (state.Buttons.HasFlag(WGI.GamepadButtons.LeftShoulder) ? Buttons.LeftShoulder : 0) |
+                (state.Buttons.HasFlag(WGI.GamepadButtons.LeftThumbstick) ? Buttons.LeftStick : 0) |
+                (state.Buttons.HasFlag(WGI.GamepadButtons.RightShoulder) ? Buttons.RightShoulder : 0) |
+                (state.Buttons.HasFlag(WGI.GamepadButtons.RightThumbstick) ? Buttons.RightStick : 0) |
+                (state.Buttons.HasFlag(WGI.GamepadButtons.Menu) ? Buttons.Start : 0) |
+                (state.Buttons.HasFlag(WGI.GamepadButtons.X) ? Buttons.X : 0) |
+                (state.Buttons.HasFlag(WGI.GamepadButtons.Y) ? Buttons.Y : 0) |
+                0;
+
+            // Check triggers
+            if (triggers.Left > TriggerThreshold)
+                buttonStates |= Buttons.LeftTrigger;
+            if (triggers.Right > TriggerThreshold)
+                buttonStates |= Buttons.RightTrigger;
+
+            var buttons = new GamePadButtons(buttonStates);
+
+            var dpad = new GamePadDPad(
+                    state.Buttons.HasFlag(WGI.GamepadButtons.DPadUp) ? ButtonState.Pressed : ButtonState.Released,
+                    state.Buttons.HasFlag(WGI.GamepadButtons.DPadDown) ? ButtonState.Pressed : ButtonState.Released,
+                    state.Buttons.HasFlag(WGI.GamepadButtons.DPadLeft) ? ButtonState.Pressed : ButtonState.Released,
+                    state.Buttons.HasFlag(WGI.GamepadButtons.DPadRight) ? ButtonState.Pressed : ButtonState.Released
+                );
+
+            var result = new GamePadState(sticks, triggers, buttons, dpad);
+            result.PacketNumber = (int)state.Timestamp;
+            return result;
+        }
+
+        private static bool PlatformSetVibration(int index, float leftMotor, float rightMotor)
+        {
+            if (!_gamepads.ContainsKey(index))
+                return false;
+
+            var gamepad = _gamepads[index];
+
+            gamepad.Vibration = new WGI.GamepadVibration
+            {
+                LeftMotor = leftMotor,
+                LeftTrigger = leftMotor,
+                RightMotor = rightMotor,
+                RightTrigger = rightMotor
+            };
+
+            return true;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePad.Web.cs b/MonoGame.Framework/Input/GamePad.Web.cs
new file mode 100644
index 00000000000..cde3795520b
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePad.Web.cs
@@ -0,0 +1,135 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using JSIL;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    static partial class GamePad
+    {
+        private static readonly Dictionary<string, string> Configurations = new Dictionary<string, string>();
+        private static Dictionary<string, GamepadTranslator> GamePadCache = new Dictionary<string, GamepadTranslator>();
+        private static int platformlimit;
+
+        static GamePad()
+        {
+            Configurations.Add("045e-028e-Microsoft X-Box 360 pad", "X360 Wireless Controller,a:b0,b:b1,x:b2,y:b3,dpup:a7,dpdown:a7,dpleft:a6,dpright:a6,leftshoulder:b4,leftstick:b9,lefttrigger:a2,rightshoulder:b5,rightstick:b10,righttrigger:a5,back:b6,start:b7,guide:b8,leftx:a0,lefty:a1,rightx:a3,righty:a4");
+            Configurations.Add("Microsoft X-Box 360 pad (STANDARD GAMEPAD Vendor: 045e Product: 028e)", "X360 Wireless Controller,a:b0,b:b1,x:b2,y:b3,dpup:b12,dpdown:b13,dpleft:b14,dpright:b15,leftshoulder:b4,leftstick:b10,lefttrigger:b6,rightshoulder:b5,rightstick:b11,righttrigger:b7,back:b8,start:b9,guide:b16,leftx:a0,lefty:a1,rightx:a2,righty:a3");
+
+            var navigator = Builtins.Global["navigator"];
+            platformlimit = navigator.getGamepads ? 16 : 4; // Chrome has a limit of 4 gamepads
+        }
+
+        private static int PlatformGetMaxNumberOfGamePads()
+        {
+            return platformlimit;
+        }
+
+        private static GamePadCapabilities PlatformGetCapabilities(int index)
+        {
+            var jcap = Joystick.GetCapabilities(index);
+
+            if (!GamePadCache.ContainsKey(jcap.Identifier))
+                GamePadCache.Add(jcap.Identifier, Configurations.ContainsKey(jcap.Identifier) ? new GamepadTranslator(Configurations[jcap.Identifier]) : new GamepadTranslator(""));
+
+            var gpc = GamePadCache[jcap.Identifier];
+
+            return new GamePadCapabilities 
+            {
+                IsConnected = true,
+                GamePadType = GamePadType.GamePad,
+                HasAButton = (gpc.Read("a").index != -1),
+                HasBButton = (gpc.Read("b").index != -1),
+                HasXButton = (gpc.Read("x").index != -1),
+                HasYButton = (gpc.Read("y").index != -1),
+                HasBackButton = (gpc.Read("back").index != -1),
+                HasStartButton = (gpc.Read("start").index != -1),
+                HasDPadDownButton = (gpc.Read("dpdown").index != -1),
+                HasDPadLeftButton = (gpc.Read("dpleft").index != -1),
+                HasDPadRightButton = (gpc.Read("dpright").index != -1),
+                HasDPadUpButton = (gpc.Read("dpup").index != -1),
+                HasLeftShoulderButton = (gpc.Read("leftshoulder").index != -1),
+                HasRightShoulderButton = (gpc.Read("rightshoulder").index != -1),
+                HasLeftStickButton = (gpc.Read("leftstick").index != -1),
+                HasRightStickButton = (gpc.Read("rightstick").index != -1),
+                HasLeftTrigger = (gpc.Read("lefttrigger").index != -1),
+                HasRightTrigger = (gpc.Read("righttrigger").index != -1),
+                HasLeftXThumbStick = (gpc.Read("leftx").index != -1),
+                HasLeftYThumbStick = (gpc.Read("lefty").index != -1),
+                HasRightXThumbStick = (gpc.Read("rightx").index != -1),
+                HasRightYThumbStick = (gpc.Read("righty").index != -1),
+                HasLeftVibrationMotor = false,
+                HasRightVibrationMotor = false,
+                HasVoiceSupport = false,
+                HasBigButton = (gpc.Read("guide").index != -1)
+            };
+        }
+
+        private static GamePadState PlatformGetState(int index, GamePadDeadZone leftDeadZoneMode, GamePadDeadZone rightDeadZoneMode)
+        {
+            var state = GamePadState.Default;
+            var jcap = Joystick.GetCapabilities(index);
+
+            if (jcap.IsConnected)
+            {
+                state.IsConnected = true;
+
+                var jstate = Joystick.GetState(index);
+
+                if (!GamePadCache.ContainsKey(jcap.Identifier))
+                    GamePadCache.Add(jcap.Identifier, Configurations.ContainsKey(jcap.Identifier) ? new GamepadTranslator(Configurations[jcap.Identifier]) : new GamepadTranslator(""));
+
+                var gpc = GamePadCache[jcap.Identifier];
+
+                Buttons buttons = 
+                    (gpc.ButtonPressed("a", jstate) ? Buttons.A : 0) |
+                    (gpc.ButtonPressed("b", jstate) ? Buttons.B : 0) |
+                    (gpc.ButtonPressed("back", jstate) ? Buttons.Back : 0) |
+                    (gpc.ButtonPressed("guide", jstate) ? Buttons.BigButton : 0) |
+                    (gpc.ButtonPressed("leftshoulder", jstate) ? Buttons.LeftShoulder : 0) |
+                    (gpc.ButtonPressed("leftstick", jstate) ? Buttons.LeftStick : 0) |
+                    (gpc.ButtonPressed("rightshoulder", jstate) ? Buttons.RightShoulder : 0) |
+                    (gpc.ButtonPressed("rightstick", jstate) ? Buttons.RightStick : 0) |
+                    (gpc.ButtonPressed("start", jstate) ? Buttons.Start : 0) |
+                    (gpc.ButtonPressed("x", jstate) ? Buttons.X : 0) |
+                    (gpc.ButtonPressed("y", jstate) ? Buttons.Y : 0) |
+                    0;
+
+                var sticks = 
+                    new GamePadThumbSticks(
+                        new Vector2(gpc.AxisPressed("leftx", jstate), gpc.AxisPressed("lefty", jstate)),
+                        new Vector2(gpc.AxisPressed("rightx", jstate), gpc.AxisPressed("righty", jstate)),
+                        leftDeadZoneMode,
+						rightDeadZoneMode
+                    );
+                
+                var dpad = 
+                    new GamePadDPad(
+                        gpc.DpadPressed("dpup", jstate) ? ButtonState.Pressed : ButtonState.Released,
+                        gpc.DpadPressed("dpdown", jstate) ? ButtonState.Pressed : ButtonState.Released,
+                        gpc.DpadPressed("dpleft", jstate) ? ButtonState.Pressed : ButtonState.Released,
+                        gpc.DpadPressed("dpright", jstate) ? ButtonState.Pressed : ButtonState.Released
+                    );
+
+                var triggers = 
+                    new GamePadTriggers(
+                        gpc.TriggerPressed("lefttrigger", jstate),
+                        gpc.TriggerPressed("righttrigger", jstate)
+                    );
+
+                
+                state = new GamePadState(sticks, triggers, new GamePadButtons(buttons), dpad);
+            }
+
+            return state;
+        }
+
+        private static bool PlatformSetVibration(int index, float leftMotor, float rightMotor)
+        {
+            return false;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePad.XInput.cs b/MonoGame.Framework/Input/GamePad.XInput.cs
new file mode 100644
index 00000000000..8f53de2ba15
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePad.XInput.cs
@@ -0,0 +1,314 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using GBF = SharpDX.XInput.GamepadButtonFlags;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    static partial class GamePad
+    {
+        internal static bool Back;
+
+        private static readonly SharpDX.XInput.Controller[] _controllers = new[]
+        {
+            new SharpDX.XInput.Controller(SharpDX.XInput.UserIndex.One),
+            new SharpDX.XInput.Controller(SharpDX.XInput.UserIndex.Two),
+            new SharpDX.XInput.Controller(SharpDX.XInput.UserIndex.Three),
+            new SharpDX.XInput.Controller(SharpDX.XInput.UserIndex.Four),
+        };
+
+        private static readonly bool[] _connected = new bool[4];
+        private static readonly long[] _timeout = new long[4];
+        private static readonly long TimeoutTicks = TimeSpan.FromSeconds(1).Ticks;
+
+        private static int PlatformGetMaxNumberOfGamePads()
+        {
+            return 4;
+        }
+
+        private static GamePadCapabilities PlatformGetCapabilities(int index)
+        {
+            // If the device was disconneced then wait for 
+            // the timeout to elapsed before we test it again.
+            if (!_connected[index] && !HasDisconnectedTimeoutElapsed(index))
+                return new GamePadCapabilities();
+      
+            // Check to see if the device is connected.
+            var controller = _controllers[index];
+            _connected[index] = controller.IsConnected;
+
+            // If the device is disconnected retry it after the
+            // timeout period has elapsed to avoid the overhead.
+            if (!_connected[index])
+            {
+                SetDisconnectedTimeout(index);
+                return new GamePadCapabilities();
+            }
+
+            var capabilities = controller.GetCapabilities(SharpDX.XInput.DeviceQueryType.Any);
+            var ret = new GamePadCapabilities();
+            switch (capabilities.SubType)
+            {
+#if DIRECTX11_1
+                case SharpDX.XInput.DeviceSubType.ArcadePad:
+                    Debug.WriteLine("XInput's DeviceSubType.ArcadePad is not supported in XNA");
+                    ret.GamePadType = Input.GamePadType.Unknown; // TODO: Should this be BigButtonPad?
+                    break;
+                case SharpDX.XInput.DeviceSubType.FlightStick:
+                    ret.GamePadType = Input.GamePadType.FlightStick;
+                    break;
+                case SharpDX.XInput.DeviceSubType.GuitarAlternate:
+                    ret.GamePadType = Input.GamePadType.AlternateGuitar;
+                    break;
+                case SharpDX.XInput.DeviceSubType.GuitarBass:
+                    // Note: XNA doesn't distinguish between Guitar and GuitarBass, but 
+                    // GuitarBass is identical to Guitar in XInput, distinguished only
+                    // to help setup for those controllers. 
+                    ret.GamePadType = Input.GamePadType.Guitar;
+                    break;
+                case SharpDX.XInput.DeviceSubType.Unknown:
+                    ret.GamePadType = Input.GamePadType.Unknown;
+                    break;
+#endif
+                case SharpDX.XInput.DeviceSubType.ArcadeStick:
+                    ret.GamePadType = GamePadType.ArcadeStick;
+                    break;
+                case SharpDX.XInput.DeviceSubType.DancePad:
+                    ret.GamePadType = GamePadType.DancePad;
+                    break;
+                case SharpDX.XInput.DeviceSubType.DrumKit:
+                    ret.GamePadType = GamePadType.DrumKit;
+                    break;
+
+                case SharpDX.XInput.DeviceSubType.Gamepad:
+                    ret.GamePadType = GamePadType.GamePad;
+                    break;
+                case SharpDX.XInput.DeviceSubType.Guitar:
+                    ret.GamePadType = GamePadType.Guitar;
+                    break;
+                case SharpDX.XInput.DeviceSubType.Wheel:
+                    ret.GamePadType = GamePadType.Wheel;
+                    break;
+                default:
+                    Debug.WriteLine("unexpected XInput DeviceSubType: {0}", capabilities.SubType.ToString());
+                    ret.GamePadType = GamePadType.Unknown;
+                    break;
+            }
+
+            var gamepad = capabilities.Gamepad;
+
+            // digital buttons
+            var buttons = gamepad.Buttons;
+            ret.HasAButton = (buttons & GBF.A) == GBF.A;
+            ret.HasBackButton = (buttons & GBF.Back) == GBF.Back;
+            ret.HasBButton = (buttons & GBF.B) == GBF.B;
+            ret.HasBigButton = false; // TODO: what IS this? Is it related to GamePadType.BigGamePad?
+            ret.HasDPadDownButton = (buttons & GBF.DPadDown) == GBF.DPadDown;
+            ret.HasDPadLeftButton = (buttons & GBF.DPadLeft) == GBF.DPadLeft;
+            ret.HasDPadRightButton = (buttons & GBF.DPadRight) == GBF.DPadRight;
+            ret.HasDPadUpButton = (buttons & GBF.DPadUp) == GBF.DPadUp;
+            ret.HasLeftShoulderButton = (buttons & GBF.LeftShoulder) == GBF.LeftShoulder;
+            ret.HasLeftStickButton = (buttons & GBF.LeftThumb) == GBF.LeftThumb;
+            ret.HasRightShoulderButton = (buttons & GBF.RightShoulder) == GBF.RightShoulder;
+            ret.HasRightStickButton = (buttons & GBF.RightThumb) == GBF.RightThumb;
+            ret.HasStartButton = (buttons & GBF.Start) == GBF.Start;
+            ret.HasXButton = (buttons & GBF.X) == GBF.X;
+            ret.HasYButton = (buttons & GBF.Y) == GBF.Y;
+
+            // analog controls
+            ret.HasRightTrigger = gamepad.RightTrigger > 0;
+            ret.HasRightXThumbStick = gamepad.RightThumbX != 0;
+            ret.HasRightYThumbStick = gamepad.RightThumbY != 0;
+            ret.HasLeftTrigger = gamepad.LeftTrigger > 0;
+            ret.HasLeftXThumbStick = gamepad.LeftThumbX != 0;
+            ret.HasLeftYThumbStick = gamepad.LeftThumbY != 0;
+
+            // vibration
+#if DIRECTX11_1
+            bool hasForceFeedback = (capabilities.Flags & SharpDX.XInput.CapabilityFlags.FfbSupported) == SharpDX.XInput.CapabilityFlags.FfbSupported;
+            ret.HasLeftVibrationMotor = hasForceFeedback && capabilities.Vibration.LeftMotorSpeed > 0;
+            ret.HasRightVibrationMotor = hasForceFeedback && capabilities.Vibration.RightMotorSpeed > 0;
+#else
+            ret.HasLeftVibrationMotor = (capabilities.Vibration.LeftMotorSpeed > 0);
+            ret.HasRightVibrationMotor = (capabilities.Vibration.RightMotorSpeed > 0);
+#endif
+
+            // other
+            ret.IsConnected = controller.IsConnected;
+            ret.HasVoiceSupport = (capabilities.Flags & SharpDX.XInput.CapabilityFlags.VoiceSupported) == SharpDX.XInput.CapabilityFlags.VoiceSupported;
+
+            return ret;
+        }
+
+        private static GamePadState GetDefaultState()
+        {
+            var state = new GamePadState();
+            state.Buttons = new GamePadButtons(Back ? Buttons.Back : 0);
+            return state;
+        }
+
+        private static GamePadState PlatformGetState(int index, GamePadDeadZone leftDeadZoneMode, GamePadDeadZone rightDeadZoneMode)
+        {
+            // If the device was disconneced then wait for 
+            // the timeout to elapsed before we test it again.
+            if (!_connected[index] && !HasDisconnectedTimeoutElapsed(index))
+                return GetDefaultState();
+
+            int packetNumber = 0;
+
+            // Try to get the controller state.
+            var gamepad = new SharpDX.XInput.Gamepad();
+            try
+            {
+                SharpDX.XInput.State xistate;
+                var controller = _controllers[index];
+                _connected[index] = controller.GetState(out xistate);
+                packetNumber = xistate.PacketNumber;
+                gamepad = xistate.Gamepad;
+            }
+            catch (Exception)
+            {
+            }
+
+            // If the device is disconnected retry it after the
+            // timeout period has elapsed to avoid the overhead.
+            if (!_connected[index])
+            {
+                SetDisconnectedTimeout(index);
+                return GetDefaultState();
+            }
+
+            var thumbSticks = new GamePadThumbSticks(
+                leftPosition: new Vector2(gamepad.LeftThumbX, gamepad.LeftThumbY) / (float)short.MaxValue,
+                rightPosition: new Vector2(gamepad.RightThumbX, gamepad.RightThumbY) / (float)short.MaxValue,
+                    leftDeadZoneMode: leftDeadZoneMode,
+					rightDeadZoneMode: rightDeadZoneMode);
+
+            var triggers = new GamePadTriggers(
+                    leftTrigger: gamepad.LeftTrigger / (float)byte.MaxValue,
+                    rightTrigger: gamepad.RightTrigger / (float)byte.MaxValue);
+
+            var dpadState = new GamePadDPad(
+                upValue: ConvertToButtonState(gamepad.Buttons, SharpDX.XInput.GamepadButtonFlags.DPadUp),
+                downValue: ConvertToButtonState(gamepad.Buttons, SharpDX.XInput.GamepadButtonFlags.DPadDown),
+                leftValue: ConvertToButtonState(gamepad.Buttons, SharpDX.XInput.GamepadButtonFlags.DPadLeft),
+                rightValue: ConvertToButtonState(gamepad.Buttons, SharpDX.XInput.GamepadButtonFlags.DPadRight));
+
+            var buttons = ConvertToButtons(
+                buttonFlags: gamepad.Buttons,
+                leftTrigger: gamepad.LeftTrigger,
+                rightTrigger: gamepad.RightTrigger);
+
+            var state = new GamePadState(
+                thumbSticks: thumbSticks,
+                triggers: triggers,
+                buttons: buttons,
+                dPad: dpadState);
+
+            state.PacketNumber = packetNumber;
+
+            return state;
+        }
+
+        private static ButtonState ConvertToButtonState(
+            SharpDX.XInput.GamepadButtonFlags buttonFlags,
+            SharpDX.XInput.GamepadButtonFlags desiredButton)
+        {
+            return ((buttonFlags & desiredButton) == desiredButton) ? ButtonState.Pressed : ButtonState.Released;
+        }
+
+        private static Buttons AddButtonIfPressed(
+            SharpDX.XInput.GamepadButtonFlags buttonFlags,
+            SharpDX.XInput.GamepadButtonFlags xInputButton,
+            Buttons xnaButton)
+        {
+            var buttonState = ((buttonFlags & xInputButton) == xInputButton) ? ButtonState.Pressed : ButtonState.Released;
+            return buttonState == ButtonState.Pressed ? xnaButton : 0;
+        }
+
+        private static GamePadButtons ConvertToButtons(SharpDX.XInput.GamepadButtonFlags buttonFlags,
+            byte leftTrigger,
+            byte rightTrigger)
+        {
+            var ret = (Buttons)0;
+            ret |= AddButtonIfPressed(buttonFlags, GBF.A, Buttons.A);
+            ret |= AddButtonIfPressed(buttonFlags, GBF.B, Buttons.B);
+            ret |= AddButtonIfPressed(buttonFlags, GBF.Back, Buttons.Back);
+            ret |= AddButtonIfPressed(buttonFlags, GBF.DPadDown, Buttons.DPadDown);
+            ret |= AddButtonIfPressed(buttonFlags, GBF.DPadLeft, Buttons.DPadLeft);
+            ret |= AddButtonIfPressed(buttonFlags, GBF.DPadRight, Buttons.DPadRight);
+            ret |= AddButtonIfPressed(buttonFlags, GBF.DPadUp, Buttons.DPadUp);
+            ret |= AddButtonIfPressed(buttonFlags, GBF.LeftShoulder, Buttons.LeftShoulder);
+            ret |= AddButtonIfPressed(buttonFlags, GBF.RightShoulder, Buttons.RightShoulder);
+            ret |= AddButtonIfPressed(buttonFlags, GBF.LeftThumb, Buttons.LeftStick);
+            ret |= AddButtonIfPressed(buttonFlags, GBF.RightThumb, Buttons.RightStick);
+            ret |= AddButtonIfPressed(buttonFlags, GBF.Start, Buttons.Start);
+            ret |= AddButtonIfPressed(buttonFlags, GBF.X, Buttons.X);
+            ret |= AddButtonIfPressed(buttonFlags, GBF.Y, Buttons.Y);
+
+            if (leftTrigger >= SharpDX.XInput.Gamepad.TriggerThreshold)
+                ret |= Buttons.LeftTrigger;
+
+            if (rightTrigger >= SharpDX.XInput.Gamepad.TriggerThreshold)
+                ret |= Buttons.RightTrigger;
+
+            // Check for the hardware back button.
+            if (Back)
+                ret |= Buttons.Back;
+
+            return new GamePadButtons(ret);
+        }
+
+        private static bool PlatformSetVibration(int index, float leftMotor, float rightMotor)
+        {
+            if (!_connected[index])
+            {
+                if (!HasDisconnectedTimeoutElapsed(index))
+                    return false;
+                if (!_controllers[index].IsConnected)
+                {
+                    SetDisconnectedTimeout(index);
+                    return false;
+                }
+                _connected[index] = true;
+            }
+
+            SharpDX.Result result;
+            try
+            {
+                var vibration = new SharpDX.XInput.Vibration
+                    {
+                        LeftMotorSpeed = (ushort)(leftMotor * ushort.MaxValue),
+                        RightMotorSpeed = (ushort)(rightMotor * ushort.MaxValue),
+                    };
+                result = _controllers[index].SetVibration(vibration);
+            }
+            catch (SharpDX.SharpDXException ex)
+            {
+                const int deviceNotConnectedHResult = unchecked((int)0x8007048f);
+                if (ex.HResult == deviceNotConnectedHResult)
+                {
+                    _connected[index] = false;
+                    SetDisconnectedTimeout(index);
+                    return false;
+                }
+                throw;
+            }
+
+            return result == SharpDX.Result.Ok;
+        }
+
+        private static bool HasDisconnectedTimeoutElapsed(int index)
+        {
+            return _timeout[index] <= DateTime.UtcNow.Ticks;
+        }
+
+        private static void SetDisconnectedTimeout(int index)
+        {
+            _timeout[index] = DateTime.UtcNow.Ticks + TimeoutTicks;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePad.cs b/MonoGame.Framework/Input/GamePad.cs
new file mode 100644
index 00000000000..ae8f0b3d05c
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePad.cs
@@ -0,0 +1,147 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary> 
+    /// Supports querying the game controllers and setting the vibration motors.
+    /// </summary>
+    public static partial class GamePad
+    {
+        /// <summary>
+        /// Returns the capabilites of the connected controller.
+        /// </summary>
+        /// <param name="playerIndex">Player index for the controller you want to query.</param>
+        /// <returns>The capabilites of the controller.</returns>
+        public static GamePadCapabilities GetCapabilities(PlayerIndex playerIndex)
+        {
+            return GetCapabilities((int)playerIndex);
+        }
+
+        /// <summary>
+        /// Returns the capabilites of the connected controller.
+        /// </summary>
+        /// <param name="index">Index for the controller you want to query.</param>
+        /// <returns>The capabilites of the controller.</returns>
+        public static GamePadCapabilities GetCapabilities(int index)
+        {
+            if (index < 0 || index >= PlatformGetMaxNumberOfGamePads())
+                return new GamePadCapabilities();
+
+            return PlatformGetCapabilities(index);
+        }
+
+        /// <summary>
+        /// Gets the current state of a game pad controller with an independent axes dead zone.
+        /// </summary>
+        /// <param name="playerIndex">Player index for the controller you want to query.</param>
+        /// <returns>The state of the controller.</returns>
+        public static GamePadState GetState(PlayerIndex playerIndex)
+        {
+            return GetState((int)playerIndex, GamePadDeadZone.IndependentAxes);
+        }
+
+        /// <summary>
+        /// Gets the current state of a game pad controller with an independent axes dead zone.
+        /// </summary>
+        /// <param name="index">Index for the controller you want to query.</param>
+        /// <returns>The state of the controller.</returns>
+        public static GamePadState GetState(int index)
+        {
+            return GetState(index, GamePadDeadZone.IndependentAxes);
+        }
+
+        /// <summary>
+        /// Gets the current state of a game pad controller, using a specified dead zone
+        /// on analog stick positions.
+        /// </summary>
+        /// <param name="playerIndex">Player index for the controller you want to query.</param>
+        /// <param name="deadZoneMode">Enumerated value that specifies what dead zone type to use.</param>
+        /// <returns>The state of the controller.</returns>
+        public static GamePadState GetState(PlayerIndex playerIndex, GamePadDeadZone deadZoneMode)
+        {
+            return GetState((int)playerIndex, deadZoneMode);
+        }
+
+        /// <summary>
+        /// Gets the current state of a game pad controller, using a specified dead zone
+        /// on analog stick positions.
+        /// </summary>
+        /// <param name="index">Index for the controller you want to query.</param>
+        /// <param name="deadZoneMode">Enumerated value that specifies what dead zone type to use.</param>
+        /// <returns>The state of the controller.</returns>
+        public static GamePadState GetState(int index, GamePadDeadZone deadZoneMode)
+        {           
+            return GetState(index, deadZoneMode, deadZoneMode);
+        }
+
+        /// <summary>
+        /// Gets the current state of a game pad controller, using a specified dead zone
+        /// on analog stick positions.
+        /// </summary>
+        /// <param name="playerIndex">Player index for the controller you want to query.</param>
+        /// <param name="leftDeadZoneMode">Enumerated value that specifies what dead zone type to use for the left stick.</param>
+        /// <param name="rightDeadZoneMode">Enumerated value that specifies what dead zone type to use for the right stick.</param>
+        /// <returns>The state of the controller.</returns>
+        public static GamePadState GetState(PlayerIndex playerIndex, GamePadDeadZone leftDeadZoneMode, GamePadDeadZone rightDeadZoneMode)
+        {
+            return GetState((int)playerIndex, leftDeadZoneMode, rightDeadZoneMode);
+        }
+
+        /// <summary>
+        /// Gets the current state of a game pad controller, using a specified dead zone
+        /// on analog stick positions.
+        /// </summary>
+        /// <param name="index">Index for the controller you want to query.</param>
+        /// <param name="leftDeadZoneMode">Enumerated value that specifies what dead zone type to use for the left stick.</param>
+        /// <param name="rightDeadZoneMode">Enumerated value that specifies what dead zone type to use for the right stick.</param>
+        /// <returns>The state of the controller.</returns>
+        public static GamePadState GetState(int index, GamePadDeadZone leftDeadZoneMode, GamePadDeadZone rightDeadZoneMode)
+        {
+            if (index < 0 || index >= PlatformGetMaxNumberOfGamePads())
+                return GamePadState.Default;
+
+            return PlatformGetState(index, leftDeadZoneMode, rightDeadZoneMode);
+        }
+
+        /// <summary>
+        /// Sets the vibration motor speeds on the controller device if supported.
+        /// </summary>
+        /// <param name="playerIndex">Player index that identifies the controller to set.</param>
+        /// <param name="leftMotor">The speed of the left motor, between 0.0 and 1.0. This motor is a low-frequency motor.</param>
+        /// <param name="rightMotor">The speed of the right motor, between 0.0 and 1.0. This motor is a high-frequency motor.</param>
+        /// <returns>Returns true if the vibration motors were set.</returns>
+        public static bool SetVibration(PlayerIndex playerIndex, float leftMotor, float rightMotor)
+        {
+            return SetVibration((int)playerIndex, leftMotor, rightMotor);
+        }
+
+        /// <summary>
+        /// Sets the vibration motor speeds on the controller device if supported.
+        /// </summary>
+        /// <param name="index">Index for the controller you want to query.</param>
+        /// <param name="leftMotor">The speed of the left motor, between 0.0 and 1.0. This motor is a low-frequency motor.</param>
+        /// <param name="rightMotor">The speed of the right motor, between 0.0 and 1.0. This motor is a high-frequency motor.</param>
+        /// <returns>Returns true if the vibration motors were set.</returns>
+        public static bool SetVibration(int index, float leftMotor, float rightMotor)
+        {
+            if (index < 0 || index >= PlatformGetMaxNumberOfGamePads())
+                return false;
+            
+            return PlatformSetVibration(index, MathHelper.Clamp(leftMotor, 0.0f, 1.0f), MathHelper.Clamp(rightMotor, 0.0f, 1.0f));
+        }
+
+        /// <summary>
+        /// The maximum number of game pads supported on this system.  Attempting to
+        /// access a gamepad index higher than this number will result in an <see cref="InvalidOperationException"/>
+        /// being thrown by the API.
+        /// </summary>
+        public static int MaximumGamePadCount
+        {
+            get { return PlatformGetMaxNumberOfGamePads(); }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePad.tvOS.cs b/MonoGame.Framework/Input/GamePad.tvOS.cs
new file mode 100644
index 00000000000..6b68e71cf6b
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePad.tvOS.cs
@@ -0,0 +1,224 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+using GameController;
+using System.Collections.Generic;
+using System.Linq;
+using UIKit;
+using System;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    static partial class GamePad
+    {
+        internal static bool MenuPressed = false;
+
+        private static int PlatformGetMaxNumberOfGamePads ()
+        {
+            return 4;
+        }
+
+        static bool IndexIsUsed (GCControllerPlayerIndex index)
+        {
+            foreach (var ctrl in GCController.Controllers)
+                if (ctrl.PlayerIndex==(int)index) return true;
+
+            return false;
+        }
+
+        static void AssingIndex(GCControllerPlayerIndex index) {
+            if (IndexIsUsed(index))
+                return;
+            foreach (var controller in GCController.Controllers)
+            {
+                if (controller.PlayerIndex == (int)index)
+                    break;
+                if (controller.PlayerIndex == (int)GCControllerPlayerIndex.Unset)
+                {
+                    controller.PlayerIndex = (int)index;
+                    break;
+                }
+            }
+        }
+
+        private static GamePadCapabilities PlatformGetCapabilities(int index)
+        {
+            var ind = (GCControllerPlayerIndex)index;
+
+            AssingIndex(ind);
+
+            foreach (var controller in GCController.Controllers)
+            {
+                if (controller == null)
+                    continue;
+                if (controller.PlayerIndex == (int)ind)
+                    return GetCapabilities(controller);
+            }
+            return new GamePadCapabilities { IsConnected = false };
+        }
+               
+        private static GamePadState PlatformGetState(int index, GamePadDeadZone leftDeadZoneMode, GamePadDeadZone rightDeadZoneMode)
+        {
+            var ind = (GCControllerPlayerIndex)index;
+
+
+            var buttons = new List<Buttons>();
+            bool connected = false;
+            ButtonState Up = ButtonState.Released;
+            ButtonState Down = ButtonState.Released;
+            ButtonState Left = ButtonState.Released;
+            ButtonState Right = ButtonState.Released;
+
+            Vector2 leftThumbStickPosition = Vector2.Zero;
+            Vector2 rightThumbStickPosition = Vector2.Zero;
+
+            float leftTriggerValue = 0;
+            float rightTriggerValue = 0;
+
+            AssingIndex(ind);
+
+            foreach  (var controller in GCController.Controllers) {
+
+                if (controller == null)
+                    continue;
+
+                if (controller.PlayerIndex != (int)ind)
+                    continue;
+
+                connected = true;
+                if (MenuPressed)
+                {
+                    buttons.Add(Buttons.Back);
+                    MenuPressed = false;
+                }
+
+                if (controller.ExtendedGamepad != null)
+                {
+                    if (controller.ExtendedGamepad.ButtonA.IsPressed == true && !buttons.Contains (Buttons.A))
+                        buttons.Add(Buttons.A);
+                    if (controller.ExtendedGamepad.ButtonB.IsPressed == true && !buttons.Contains (Buttons.B))
+                        buttons.Add(Buttons.B);
+                    if (controller.ExtendedGamepad.ButtonX.IsPressed == true && !buttons.Contains (Buttons.X))
+                        buttons.Add(Buttons.X);
+                    if (controller.ExtendedGamepad.ButtonY.IsPressed == true && !buttons.Contains (Buttons.Y))
+                        buttons.Add(Buttons.Y);
+
+                    if (controller.ExtendedGamepad.LeftShoulder.IsPressed == true && !buttons.Contains (Buttons.LeftShoulder))
+                        buttons.Add (Buttons.LeftShoulder);
+                    if (controller.ExtendedGamepad.RightShoulder.IsPressed == true && !buttons.Contains (Buttons.RightShoulder))
+                        buttons.Add (Buttons.RightShoulder);
+
+                    Up = controller.ExtendedGamepad.DPad.Up.IsPressed ? ButtonState.Pressed : ButtonState.Released;
+                    Down = controller.ExtendedGamepad.DPad.Down.IsPressed ? ButtonState.Pressed : ButtonState.Released;
+                    Left = controller.ExtendedGamepad.DPad.Left.IsPressed ? ButtonState.Pressed : ButtonState.Released;
+                    Right = controller.ExtendedGamepad.DPad.Right.IsPressed ? ButtonState.Pressed : ButtonState.Released;
+
+                    leftThumbStickPosition.X = controller.ExtendedGamepad.LeftThumbstick.XAxis.Value;
+                    leftThumbStickPosition.Y = controller.ExtendedGamepad.LeftThumbstick.YAxis.Value;
+
+                    rightThumbStickPosition.X = controller.ExtendedGamepad.RightThumbstick.XAxis.Value;
+                    rightThumbStickPosition.Y = controller.ExtendedGamepad.RightThumbstick.YAxis.Value;
+
+                    leftTriggerValue = controller.ExtendedGamepad.LeftTrigger.Value;
+                    rightTriggerValue = controller.ExtendedGamepad.RightTrigger.Value;
+                }
+                else if (controller.Gamepad != null)
+                {
+                    if (controller.Gamepad.ButtonA.IsPressed == true && !buttons.Contains (Buttons.A))
+                        buttons.Add(Buttons.A);
+                    if (controller.Gamepad.ButtonB.IsPressed == true && !buttons.Contains (Buttons.B))
+                        buttons.Add(Buttons.B);
+                    if (controller.Gamepad.ButtonX.IsPressed == true && !buttons.Contains (Buttons.X))
+                        buttons.Add(Buttons.X);
+                    if (controller.Gamepad.ButtonY.IsPressed == true && !buttons.Contains (Buttons.Y))
+                        buttons.Add(Buttons.Y);
+                    Up = controller.Gamepad.DPad.Up.IsPressed ? ButtonState.Pressed : ButtonState.Released;
+                    Down = controller.Gamepad.DPad.Down.IsPressed ? ButtonState.Pressed : ButtonState.Released;
+                    Left = controller.Gamepad.DPad.Left.IsPressed ? ButtonState.Pressed : ButtonState.Released;
+                    Right = controller.Gamepad.DPad.Right.IsPressed ? ButtonState.Pressed : ButtonState.Released;
+
+                }
+                else if (controller.MicroGamepad != null)
+                {
+                    if (controller.MicroGamepad.ButtonA.IsPressed == true && !buttons.Contains (Buttons.A))
+                        buttons.Add(Buttons.A);
+                    if (controller.MicroGamepad.ButtonX.IsPressed == true && !buttons.Contains (Buttons.X))
+                        buttons.Add(Buttons.X);
+                    Up = controller.MicroGamepad.Dpad.Up.IsPressed ? ButtonState.Pressed : ButtonState.Released;
+                    Down = controller.MicroGamepad.Dpad.Down.IsPressed ? ButtonState.Pressed : ButtonState.Released;
+                    Left = controller.MicroGamepad.Dpad.Left.IsPressed ? ButtonState.Pressed : ButtonState.Released;
+                    Right = controller.MicroGamepad.Dpad.Right.IsPressed ? ButtonState.Pressed : ButtonState.Released;
+                }
+            }
+            var state = new GamePadState(
+                new GamePadThumbSticks(leftThumbStickPosition, rightThumbStickPosition, leftDeadZoneMode, rightDeadZoneMode),
+                new GamePadTriggers(leftTriggerValue, rightTriggerValue),
+                new GamePadButtons(buttons.ToArray()),
+                new GamePadDPad (Up, Down, Left, Right));
+            state.IsConnected = connected;
+            return state;
+        }
+
+        private static bool PlatformSetVibration(int index, float leftMotor, float rightMotor)
+        {
+            return false;
+        }
+
+        private static GamePadCapabilities GetCapabilities(GCController controller)
+        {
+            //All iOS controllers have these basics
+            var capabilities = new GamePadCapabilities()
+                {
+                    IsConnected = false,
+                    GamePadType = GamePadType.GamePad,
+                };
+            if (controller.ExtendedGamepad != null)
+            {
+                capabilities.HasAButton = true;
+                capabilities.HasBButton = true;
+                capabilities.HasXButton = true;
+                capabilities.HasYButton = true;
+                capabilities.HasBackButton = true;
+                capabilities.HasDPadUpButton = true;
+                capabilities.HasDPadDownButton = true;
+                capabilities.HasDPadLeftButton = true;
+                capabilities.HasDPadRightButton = true;
+                capabilities.HasLeftShoulderButton = true;
+                capabilities.HasRightShoulderButton = true;
+                capabilities.HasLeftTrigger = true;
+                capabilities.HasRightTrigger = true;
+                capabilities.HasLeftXThumbStick = true;
+                capabilities.HasLeftYThumbStick = true;
+                capabilities.HasRightXThumbStick = true;
+                capabilities.HasRightYThumbStick = true;
+            }
+            else if (controller.Gamepad != null)
+            {
+                capabilities.HasAButton = true;
+                capabilities.HasBButton = true;
+                capabilities.HasXButton = true;
+                capabilities.HasYButton = true;
+                capabilities.HasBackButton = true;
+                capabilities.HasDPadUpButton = true;
+                capabilities.HasDPadDownButton = true;
+                capabilities.HasDPadLeftButton = true;
+                capabilities.HasDPadRightButton = true;
+                capabilities.HasLeftShoulderButton = true;
+                capabilities.HasRightShoulderButton = true;
+            }
+            else if (controller.MicroGamepad != null)
+            {
+                capabilities.HasAButton = true;
+                capabilities.HasXButton = true;
+                capabilities.HasBackButton = true;
+                capabilities.HasDPadUpButton = true;
+                capabilities.HasDPadDownButton = true;
+                capabilities.HasDPadLeftButton = true;
+                capabilities.HasDPadRightButton = true;
+            }
+            return capabilities;
+        }
+
+
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePadButtons.cs b/MonoGame.Framework/Input/GamePadButtons.cs
new file mode 100644
index 00000000000..d0aa664bdac
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePadButtons.cs
@@ -0,0 +1,221 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// A struct that represents the current button states for the controller.
+    /// </summary>
+    public struct GamePadButtons
+    {
+        internal readonly Buttons _buttons;
+
+        /// <summary>
+        /// Gets a value indicating if the button A is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the button A is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState A
+        {
+            get
+            {
+                return ((_buttons & Buttons.A) == Buttons.A) ? ButtonState.Pressed : ButtonState.Released;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating if the button B is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the button B is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState B
+        {
+            get
+            {
+                return ((_buttons & Buttons.B) == Buttons.B) ? ButtonState.Pressed : ButtonState.Released;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating if the button Back is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the button Back is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState Back
+        {
+            get
+            {
+                return ((_buttons & Buttons.Back) == Buttons.Back) ? ButtonState.Pressed : ButtonState.Released;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating if the button X is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the button X is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState X
+        {
+            get
+            {
+                return ((_buttons & Buttons.X) == Buttons.X) ? ButtonState.Pressed : ButtonState.Released;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating if the button Y is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the button Y is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState Y
+        {
+            get
+            {
+                return ((_buttons & Buttons.Y) == Buttons.Y) ? ButtonState.Pressed : ButtonState.Released;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating if the button Start is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the button Start is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState Start
+        {
+            get
+            {
+                return ((_buttons & Buttons.Start) == Buttons.Start) ? ButtonState.Pressed : ButtonState.Released;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating if the left shoulder button is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the left shoulder button is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState LeftShoulder
+        {
+            get
+            {
+                return ((_buttons & Buttons.LeftShoulder) == Buttons.LeftShoulder) ? ButtonState.Pressed : ButtonState.Released;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating if the left stick button is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the left stick button is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState LeftStick
+        {
+            get
+            {
+                return ((_buttons & Buttons.LeftStick) == Buttons.LeftStick) ? ButtonState.Pressed : ButtonState.Released;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating if the right shoulder button is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the right shoulder button is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState RightShoulder
+        {
+            get
+            {
+                return ((_buttons & Buttons.RightShoulder) == Buttons.RightShoulder) ? ButtonState.Pressed : ButtonState.Released;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating if the right stick button is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the right stick button is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState RightStick
+        {
+            get
+            {
+                return ((_buttons & Buttons.RightStick) == Buttons.RightStick) ? ButtonState.Pressed : ButtonState.Released;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating if the guide button is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the guide button is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState BigButton
+        {
+            get
+            {
+                return ((_buttons & Buttons.BigButton) == Buttons.BigButton) ? ButtonState.Pressed : ButtonState.Released;
+            }
+        }
+        
+        public GamePadButtons(Buttons buttons)
+        {
+            _buttons = buttons;
+        }
+
+        internal GamePadButtons(params Buttons[] buttons) : this()
+        {
+            foreach (Buttons b in buttons)
+                _buttons |= b;
+        }
+
+        /// <summary>
+        /// Determines whether two specified instances of <see cref="GamePadButtons"/> are equal.
+        /// </summary>
+        /// <param name="left">The first object to compare.</param>
+        /// <param name="right">The second object to compare.</param>
+        /// <returns>true if <paramref name="left"/> and <paramref name="right"/> are equal; otherwise, false.</returns>
+        public static bool operator ==(GamePadButtons left, GamePadButtons right)
+        {
+            return left._buttons == right._buttons;
+        }
+
+        /// <summary>
+        /// Determines whether two specified instances of <see cref="GamePadButtons"/> are not equal.
+        /// </summary>
+        /// <param name="left">The first object to compare.</param>
+        /// <param name="right">The second object to compare.</param>
+        /// <returns>true if <paramref name="left"/> and <paramref name="right"/> are not equal; otherwise, false.</returns>
+        public static bool operator !=(GamePadButtons left, GamePadButtons right)
+        {
+            return !(left == right);
+        }
+
+        /// <summary>
+        /// Returns a value indicating whether this instance is equal to a specified object.
+        /// </summary>
+        /// <param name="obj">An object to compare to this instance.</param>
+        /// <returns>true if <paramref name="obj"/> is a <see cref="GamePadButtons"/> and has the same value as this instance; otherwise, false.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is GamePadButtons) && (this == (GamePadButtons)obj);
+        }
+
+        /// <summary>
+        /// Serves as a hash function for a <see cref="T:Microsoft.Xna.Framework.Input.GamePadButtons"/> object.
+        /// </summary>
+        /// <returns>A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a
+        /// hash table.</returns>
+        public override int GetHashCode ()
+        {
+            return (int)_buttons;
+        }
+
+        /// <summary>
+        /// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadButtons"/>.
+        /// </summary>
+        /// <returns>A <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadButtons"/>.</returns>
+        public override string ToString()
+        {
+            return "[GamePadButtons:" +
+                " A=" + (int)A +
+                ", B=" + (int)B +
+                ", Back=" + (int)Back +
+                ", X=" + (int)X +
+                ", Y=" + (int)Y +
+                ", Start=" + (int)Start +
+                ", LeftShoulder=" + (int)LeftShoulder +
+                ", LeftStick=" + (int)LeftStick +
+                ", RightShoulder=" + (int)RightShoulder +
+                ", RightStick=" + (int)RightStick +
+                ", BigButton=" + (int)BigButton +
+                "]";
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Input/GamePadCapabilities.cs b/MonoGame.Framework/Input/GamePadCapabilities.cs
new file mode 100644
index 00000000000..1212aa292bf
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePadCapabilities.cs
@@ -0,0 +1,297 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// A stuct that represents the controller capabilities.
+    /// </summary>
+    public struct GamePadCapabilities
+    {
+        /// <summary>
+        /// Gets a value indicating if the controller is connected.
+        /// </summary>
+        /// <value><c>true</c> if it is connected; otherwise, <c>false</c>.</value>
+        public bool IsConnected { get; internal set; }
+
+        /// <summary>
+        /// Gets the gamepad display name.
+        /// 
+        /// This property is not available in XNA.
+        /// </summary>
+        /// <value>String representing the display name of the gamepad.</value>
+        public string DisplayName { get; internal set; }
+
+        /// <summary>
+        /// Gets the unique identifier of the gamepad.
+        /// 
+        /// This property is not available in XNA.
+        /// </summary>
+        /// <value>String representing the unique identifier of the gamepad.</value>
+        public string Identifier { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the button A.
+        /// </summary>
+        /// <value><c>true</c> if it has the button A; otherwise, <c>false</c>.</value>
+        public bool HasAButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the button Back.
+        /// </summary>
+        /// <value><c>true</c> if it has the button Back; otherwise, <c>false</c>.</value>
+        public bool HasBackButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the button B.
+        /// </summary>
+        /// <value><c>true</c> if it has the button B; otherwise, <c>false</c>.</value>
+        public bool HasBButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the directional pad down button.
+        /// </summary>
+        /// <value><c>true</c> if it has the directional pad down button; otherwise, <c>false</c>.</value>
+        public bool HasDPadDownButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the directional pad left button.
+        /// </summary>
+        /// <value><c>true</c> if it has the directional pad left button; otherwise, <c>false</c>.</value>
+        public bool HasDPadLeftButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the directional pad right button.
+        /// </summary>
+        /// <value><c>true</c> if it has the directional pad right button; otherwise, <c>false</c>.</value>
+        public bool HasDPadRightButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the directional pad up button.
+        /// </summary>
+        /// <value><c>true</c> if it has the directional pad up button; otherwise, <c>false</c>.</value>
+        public bool HasDPadUpButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the left shoulder button.
+        /// </summary>
+        /// <value><c>true</c> if it has the left shoulder button; otherwise, <c>false</c>.</value>
+        public bool HasLeftShoulderButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the left stick button.
+        /// </summary>
+        /// <value><c>true</c> if it has the left stick button; otherwise, <c>false</c>.</value>
+        public bool HasLeftStickButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the right shoulder button.
+        /// </summary>
+        /// <value><c>true</c> if it has the right shoulder button; otherwise, <c>false</c>.</value>
+        public bool HasRightShoulderButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the right stick button.
+        /// </summary>
+        /// <value><c>true</c> if it has the right stick button; otherwise, <c>false</c>.</value>
+        public bool HasRightStickButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the button Start.
+        /// </summary>
+        /// <value><c>true</c> if it has the button Start; otherwise, <c>false</c>.</value>
+        public bool HasStartButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the button X.
+        /// </summary>
+        /// <value><c>true</c> if it has the button X; otherwise, <c>false</c>.</value>
+        public bool HasXButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the button Y.
+        /// </summary>
+        /// <value><c>true</c> if it has the button Y; otherwise, <c>false</c>.</value>
+        public bool HasYButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the guide button.
+        /// </summary>
+        /// <value><c>true</c> if it has the guide button; otherwise, <c>false</c>.</value>
+        public bool HasBigButton { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has X axis for the left stick (thumbstick) button.
+        /// </summary>
+        /// <value><c>true</c> if it has X axis for the left stick (thumbstick) button; otherwise, <c>false</c>.</value>
+        public bool HasLeftXThumbStick { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has Y axis for the left stick (thumbstick) button.
+        /// </summary>
+        /// <value><c>true</c> if it has Y axis for the left stick (thumbstick) button; otherwise, <c>false</c>.</value>
+        public bool HasLeftYThumbStick { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has X axis for the right stick (thumbstick) button.
+        /// </summary>
+        /// <value><c>true</c> if it has X axis for the right stick (thumbstick) button; otherwise, <c>false</c>.</value>
+        public bool HasRightXThumbStick { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has Y axis for the right stick (thumbstick) button.
+        /// </summary>
+        /// <value><c>true</c> if it has Y axis for the right stick (thumbstick) button; otherwise, <c>false</c>.</value>
+        public bool HasRightYThumbStick { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the left trigger button.
+        /// </summary>
+        /// <value><c>true</c> if it has the left trigger button; otherwise, <c>false</c>.</value>
+        public bool HasLeftTrigger { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the right trigger button.
+        /// </summary>
+        /// <value><c>true</c> if it has the right trigger button; otherwise, <c>false</c>.</value>
+        public bool HasRightTrigger { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the left vibration motor.
+        /// </summary>
+        /// <value><c>true</c> if it has the left vibration motor; otherwise, <c>false</c>.</value>
+        public bool HasLeftVibrationMotor { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has the right vibration motor.
+        /// </summary>
+        /// <value><c>true</c> if it has the right vibration motor; otherwise, <c>false</c>.</value>
+        public bool HasRightVibrationMotor { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the controller has a microphone.
+        /// </summary>
+        /// <value><c>true</c> if it has a microphone; otherwise, <c>false</c>.</value>
+        public bool HasVoiceSupport { get; internal set; }
+
+        /// <summary>
+        /// Gets the type of the controller.
+        /// </summary>
+        /// <value>A <see cref="GamePadType"/> representing the controller type..</value>
+        public GamePadType GamePadType { get; internal set; }
+
+        /// <summary>
+        /// Determines whether a specified instance of <see cref="Microsoft.Xna.Framework.Input.GamePadCapabilities"/>
+        /// is equal to another specified <see cref="Microsoft.Xna.Framework.Input.GamePadCapabilities"/>.
+        /// </summary>
+        /// <param name="left">The first <see cref="Microsoft.Xna.Framework.Input.GamePadCapabilities"/> to compare.</param>
+        /// <param name="right">The second <see cref="Microsoft.Xna.Framework.Input.GamePadCapabilities"/> to compare.</param>
+        /// <returns><c>true</c> if <c>left</c> and <c>right</c> are equal; otherwise, <c>false</c>.</returns>
+        public static bool operator ==(GamePadCapabilities left, GamePadCapabilities right)
+        {
+            var eq = true;
+
+            eq &= (left.DisplayName == right.DisplayName);
+            eq &= (left.Identifier == right.Identifier);
+            eq &= (left.IsConnected == right.IsConnected);
+            eq &= (left.HasAButton == right.HasAButton);
+            eq &= (left.HasBackButton == right.HasBackButton);
+            eq &= (left.HasBButton == right.HasBButton);
+            eq &= (left.HasDPadDownButton == right.HasDPadDownButton);
+            eq &= (left.HasDPadLeftButton == right.HasDPadLeftButton);
+            eq &= (left.HasDPadRightButton == right.HasDPadRightButton);
+            eq &= (left.HasDPadUpButton == right.HasDPadUpButton);
+            eq &= (left.HasLeftShoulderButton == right.HasLeftShoulderButton);
+            eq &= (left.HasLeftStickButton == right.HasLeftStickButton);
+            eq &= (left.HasRightShoulderButton == right.HasRightShoulderButton);
+            eq &= (left.HasRightStickButton == right.HasRightStickButton);
+            eq &= (left.HasStartButton == right.HasStartButton);
+            eq &= (left.HasXButton == right.HasXButton);
+            eq &= (left.HasYButton == right.HasYButton);
+            eq &= (left.HasBigButton == right.HasBigButton);
+            eq &= (left.HasLeftXThumbStick == right.HasLeftXThumbStick);
+            eq &= (left.HasLeftYThumbStick == right.HasLeftYThumbStick);
+            eq &= (left.HasRightXThumbStick == right.HasRightXThumbStick);
+            eq &= (left.HasRightYThumbStick == right.HasRightYThumbStick);
+            eq &= (left.HasLeftTrigger == right.HasLeftTrigger);
+            eq &= (left.HasRightTrigger == right.HasRightTrigger);
+            eq &= (left.HasLeftVibrationMotor == right.HasLeftVibrationMotor);
+            eq &= (left.HasRightVibrationMotor == right.HasRightVibrationMotor);
+            eq &= (left.HasVoiceSupport == right.HasVoiceSupport);
+            eq &= (left.GamePadType == right.GamePadType);
+
+            return eq;
+        }
+
+        /// <summary>
+        /// Determines whether a specified instance of <see cref="Microsoft.Xna.Framework.Input.GamePadCapabilities"/>
+        /// is not equal to another specified <see cref="Microsoft.Xna.Framework.Input.GamePadCapabilities"/>.
+        /// </summary>
+        /// <param name="left">The first <see cref="Microsoft.Xna.Framework.Input.GamePadCapabilities"/> to compare.</param>
+        /// <param name="right">The second <see cref="Microsoft.Xna.Framework.Input.GamePadCapabilities"/> to compare.</param>
+        /// <returns><c>true</c> if <c>left</c> and <c>right</c> are not equal; otherwise, <c>false</c>.</returns>
+        public static bool operator !=(GamePadCapabilities left, GamePadCapabilities right)
+        {
+            return !(left == right);
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="object"/> is equal to the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadCapabilities"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="object"/> to compare with the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadCapabilities"/>.</param>
+        /// <returns><c>true</c> if the specified <see cref="object"/> is equal to the current
+        /// <see cref="T:Microsoft.Xna.Framework.Input.GamePadCapabilities"/>; otherwise, <c>false</c>.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is GamePadCapabilities) && (this == (GamePadCapabilities)obj);
+        }
+
+        /// <summary>
+        /// Serves as a hash function for a <see cref="T:Microsoft.Xna.Framework.Input.GamePadCapabilities"/> object.
+        /// </summary>
+        /// <returns>A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a
+        /// hash table.</returns>
+        public override int GetHashCode()
+        {
+            return Identifier.GetHashCode();
+        }
+
+        /// <summary>
+        /// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadCapabilities"/>.
+        /// </summary>
+        /// <returns>A <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadCapabilities"/>.</returns>
+        public override string ToString()
+        {
+            return "[GamePadCapabilities: IsConnected=" + IsConnected +
+                ", DisplayName=" + DisplayName +
+                ", Identifier=" + Identifier +
+                ", HasAButton=" + HasAButton +
+                ", HasBackButton=" + HasBackButton +
+                ", HasBButton=" + HasBButton +
+                ", HasDPadDownButton=" + HasDPadDownButton +
+                ", HasDPadLeftButton=" + HasDPadLeftButton +
+                ", HasDPadRightButton=" + HasDPadRightButton +
+                ", HasDPadUpButton=" + HasDPadUpButton +
+                ", HasLeftShoulderButton=" + HasLeftShoulderButton +
+                ", HasLeftStickButton=" + HasLeftStickButton +
+                ", HasRightShoulderButton=" + HasRightShoulderButton +
+                ", HasRightStickButton=" + HasRightStickButton +
+                ", HasStartButton=" + HasStartButton +
+                ", HasXButton=" + HasXButton +
+                ", HasYButton=" + HasYButton +
+                ", HasBigButton=" + HasBigButton +
+                ", HasLeftXThumbStick=" + HasLeftXThumbStick +
+                ", HasLeftYThumbStick=" + HasLeftYThumbStick +
+                ", HasRightXThumbStick=" + HasRightXThumbStick +
+                ", HasRightYThumbStick=" + HasRightYThumbStick +
+                ", HasLeftTrigger=" + HasLeftTrigger +
+                ", HasRightTrigger=" + HasRightTrigger +
+                ", HasLeftVibrationMotor=" + HasLeftVibrationMotor +
+                ", HasRightVibrationMotor=" + HasRightVibrationMotor +
+                ", HasVoiceSupport=" + HasVoiceSupport +
+                ", GamePadType=" + GamePadType +
+                "]";
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePadDPad.cs b/MonoGame.Framework/Input/GamePadDPad.cs
new file mode 100644
index 00000000000..43392af1130
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePadDPad.cs
@@ -0,0 +1,132 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public struct GamePadDPad
+    {
+        /// <summary>
+        /// Gets a value indicating wethever down is pressed on the directional pad.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the down button is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState Down { get; private set; }
+
+        /// <summary>
+        /// Gets a value indicating wethever left is pressed on the directional pad.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the left button is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState Left { get; private set; }
+
+        /// <summary>
+        /// Gets a value indicating wethever right is pressed on the directional pad.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the right button is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState Right { get; private set; }
+
+        /// <summary>
+        /// Gets a value indicating wethever up is pressed on the directional pad.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the up button is pressed; otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState Up { get; private set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:Microsoft.Xna.Framework.Input.GamePadDPad"/> struct.
+        /// </summary>
+        /// <param name="upValue">Current state of directional pad up.</param>
+        /// <param name="downValue">Current state of directional pad down.</param>
+        /// <param name="leftValue">Current state of directional pad left.</param>
+        /// <param name="rightValue">Current state of directional pad right.</param>
+        public GamePadDPad(ButtonState upValue, ButtonState downValue, ButtonState leftValue, ButtonState rightValue) : this()
+        {
+            Up = upValue;
+            Down = downValue;
+            Left = leftValue;
+            Right = rightValue;
+        }
+
+        internal GamePadDPad(Buttons[] buttons) : this()
+        {
+            foreach (var button in buttons)
+            {
+                ConvertButtonToDirection(button);
+            }
+        }
+
+        internal GamePadDPad(Buttons button) : this()
+        {
+            ConvertButtonToDirection(button);
+        }
+
+        /// <summary>
+        /// Determines whether two specified instances of <see cref="GamePadDPad"/> are equal.
+        /// </summary>
+        /// <param name="left">The first object to compare.</param>
+        /// <param name="right">The second object to compare.</param>
+        /// <returns>true if <paramref name="left"/> and <paramref name="right"/> are equal; otherwise, false.</returns>
+        public static bool operator ==(GamePadDPad left, GamePadDPad right)
+        {
+            return (left.Down == right.Down)
+                && (left.Left == right.Left)
+                && (left.Right == right.Right)
+                && (left.Up == right.Up);
+        }
+
+        /// <summary>
+        /// Determines whether two specified instances of <see cref="GamePadDPad"/> are not equal.
+        /// </summary>
+        /// <param name="left">The first object to compare.</param>
+        /// <param name="right">The second object to compare.</param>
+        /// <returns>true if <paramref name="left"/> and <paramref name="right"/> are not equal; otherwise, false.</returns>
+        public static bool operator !=(GamePadDPad left, GamePadDPad right)
+        {
+            return !(left == right);
+        }
+
+        /// <summary>
+        /// Returns a value indicating whether this instance is equal to a specified object.
+        /// </summary>
+        /// <param name="obj">An object to compare to this instance.</param>
+        /// <returns>true if <paramref name="obj"/> is a <see cref="GamePadDPad"/> and has the same value as this instance; otherwise, false.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is GamePadDPad) && (this == (GamePadDPad)obj);
+        }
+
+        /// <summary>
+        /// Serves as a hash function for a <see cref="T:Microsoft.Xna.Framework.Input.GamePadDPad"/> object.
+        /// </summary>
+        /// <returns>A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a
+        /// hash table.</returns>
+        public override int GetHashCode()
+        {
+            return
+                (Down == ButtonState.Pressed ? 1 : 0) +
+                (Left == ButtonState.Pressed ? 2 : 0) +
+                (Right == ButtonState.Pressed ? 4 : 0) +
+                (Up == ButtonState.Pressed ? 8 : 0);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadDPad"/>
+        /// in a format of 0000 where each number represents a boolean value of each respecting object property: Left, Up, Right, Down.
+        /// </summary>
+        /// <returns>A <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadDPad"/>.</returns>
+        public override string ToString()
+        {
+            return "" + (int)Left + (int)Up + (int)Right + (int)Down;
+        }
+
+        private void ConvertButtonToDirection(Buttons button)
+        {
+            if ((button & Buttons.DPadDown) == Buttons.DPadDown)
+                Down = ButtonState.Pressed;
+            if ((button & Buttons.DPadLeft) == Buttons.DPadLeft)
+                Left = ButtonState.Pressed;
+            if ((button & Buttons.DPadRight) == Buttons.DPadRight)
+                Right = ButtonState.Pressed;
+            if ((button & Buttons.DPadUp) == Buttons.DPadUp)
+                Up = ButtonState.Pressed;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePadDeadZone.cs b/MonoGame.Framework/Input/GamePadDeadZone.cs
new file mode 100644
index 00000000000..38cbb220f28
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePadDeadZone.cs
@@ -0,0 +1,31 @@
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Specifies a type of dead zone processing to apply to Xbox 360 Controller
+    /// analog sticks when calling GetState.
+    /// </summary>
+    public enum GamePadDeadZone
+    {
+        /// <summary>
+        /// The values of each stick are not processed and are returned by GetState as
+        /// "raw" values. This is best if you intend to implement your own dead zone
+        /// processing.
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// The X and Y positions of each stick are compared against the dead zone independently.
+        /// This setting is the default when calling GetState.
+        /// </summary>
+        IndependentAxes,
+
+        /// <summary>
+        /// The combined X and Y position of each stick is compared to the dead zone.
+        /// This provides better control than IndependentAxes when the stick is used
+        /// as a two-dimensional control surface, such as when controlling a character's
+        /// view in a first-person game.
+        /// </summary>
+        Circular
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePadState.cs b/MonoGame.Framework/Input/GamePadState.cs
new file mode 100644
index 00000000000..46f22ddf949
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePadState.cs
@@ -0,0 +1,227 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Represents specific information about the state of the controller,
+    /// including the current state of buttons and sticks.
+    ///
+    /// This is implemented as a partial struct to allow for individual platforms
+    /// to offer additional data without separate state queries to GamePad.
+    /// </summary>
+    public partial struct GamePadState
+    {
+        /// <summary>
+        /// The default initialized gamepad state.
+        /// </summary>
+        public static readonly GamePadState Default = new GamePadState();
+
+        /// <summary>
+        /// Gets a value indicating if the controller is connected.
+        /// </summary>
+        /// <value><c>true</c> if it is connected; otherwise, <c>false</c>.</value>
+        public bool IsConnected { get; internal set; }
+
+        /// <summary>
+        /// Gets the packet number associated with this state.
+        /// </summary>
+        /// <value>The packet number.</value>
+        public int PacketNumber { get; internal set; }
+
+        /// <summary>
+        /// Gets a structure that identifies what buttons on the controller are pressed.
+        /// </summary>
+        /// <value>The buttons structure.</value>
+        public GamePadButtons Buttons { get; internal set; }
+
+        /// <summary>
+        /// Gets a structure that identifies what directions of the directional pad on the controller are pressed.
+        /// </summary>
+        /// <value>The directional pad structure.</value>
+        public GamePadDPad DPad { get; internal set; }
+
+        /// <summary>
+        /// Gets a structure that indicates the position of the controller sticks (thumbsticks).
+        /// </summary>
+        /// <value>The thumbsticks position.</value>
+        public GamePadThumbSticks ThumbSticks { get; internal set; }
+
+        /// <summary>
+        /// Gets a structure that identifies the position of triggers on the controller.
+        /// </summary>
+        /// <value>Positions of the triggers.</value>
+        public GamePadTriggers Triggers { get; internal set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:Microsoft.Xna.Framework.Input.GamePadState"/> struct
+        /// using the specified GamePadThumbSticks, GamePadTriggers, GamePadButtons, and GamePadDPad.
+        /// </summary>
+        /// <param name="thumbSticks">Initial thumbstick state.</param>
+        /// <param name="triggers">Initial trigger state..</param>
+        /// <param name="buttons">Initial button state.</param>
+        /// <param name="dPad">Initial directional pad state.</param>
+        public GamePadState(GamePadThumbSticks thumbSticks, GamePadTriggers triggers, GamePadButtons buttons, GamePadDPad dPad) : this()
+        {
+            ThumbSticks = thumbSticks;
+            Triggers = triggers;
+            Buttons = buttons;
+            DPad = dPad;
+            IsConnected = true;
+
+            PlatformConstruct();
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:Microsoft.Xna.Framework.Input.GamePadState"/> struct
+        /// using the specified stick, trigger, and button values.
+        /// </summary>
+        /// <param name="leftThumbStick">Left stick value. Each axis is clamped between −1.0 and 1.0.</param>
+        /// <param name="rightThumbStick">Right stick value. Each axis is clamped between −1.0 and 1.0.</param>
+        /// <param name="leftTrigger">Left trigger value. This value is clamped between 0.0 and 1.0.</param>
+        /// <param name="rightTrigger">Right trigger value. This value is clamped between 0.0 and 1.0.</param>
+        /// <param name="button">Button(s) to initialize as pressed.</param>
+        public GamePadState(Vector2 leftThumbStick, Vector2 rightThumbStick, float leftTrigger, float rightTrigger, Buttons button)
+            : this(new GamePadThumbSticks(leftThumbStick, rightThumbStick), new GamePadTriggers(leftTrigger, rightTrigger), new GamePadButtons(button), new GamePadDPad(button))
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:Microsoft.Xna.Framework.Input.GamePadState"/> struct
+        /// using the specified stick, trigger, and button values.
+        /// </summary>
+        /// <param name="leftThumbStick">Left stick value. Each axis is clamped between −1.0 and 1.0.</param>
+        /// <param name="rightThumbStick">Right stick value. Each axis is clamped between −1.0 and 1.0.</param>
+        /// <param name="leftTrigger">Left trigger value. This value is clamped between 0.0 and 1.0.</param>
+        /// <param name="rightTrigger">Right trigger value. This value is clamped between 0.0 and 1.0.</param>
+        /// <param name="buttons"> Array of Buttons to initialize as pressed.</param>
+        public GamePadState(Vector2 leftThumbStick, Vector2 rightThumbStick, float leftTrigger, float rightTrigger, Buttons[] buttons)
+            : this(new GamePadThumbSticks(leftThumbStick, rightThumbStick), new GamePadTriggers(leftTrigger, rightTrigger), new GamePadButtons(buttons), new GamePadDPad(buttons))
+        {
+        }
+
+        /// <summary>
+        /// Define this method in platform partial classes to initialize default
+        /// values for platform-specific fields.
+        /// </summary>
+        partial void PlatformConstruct();
+
+        /// <summary>
+        /// Gets the button mask along with 'virtual buttons' like LeftThumbstickLeft.
+        /// </summary>
+        private Buttons GetVirtualButtons ()
+        {
+            var result = Buttons._buttons;
+
+            result |= ThumbSticks._virtualButtons;
+
+            if (DPad.Down == ButtonState.Pressed)
+                result |= Microsoft.Xna.Framework.Input.Buttons.DPadDown;
+            if (DPad.Up == ButtonState.Pressed)
+                result |= Microsoft.Xna.Framework.Input.Buttons.DPadUp;
+            if (DPad.Left == ButtonState.Pressed)
+                result |= Microsoft.Xna.Framework.Input.Buttons.DPadLeft;
+            if (DPad.Right == ButtonState.Pressed)
+                result |= Microsoft.Xna.Framework.Input.Buttons.DPadRight;
+
+            return result;
+        }
+
+        /// <summary>
+        /// Determines whether specified input device buttons are pressed in this GamePadState.
+        /// </summary>
+        /// <returns><c>true</c>, if button was pressed, <c>false</c> otherwise.</returns>
+        /// <param name="button">Buttons to query. Specify a single button, or combine multiple buttons using a bitwise OR operation.</param>
+        public bool IsButtonDown(Buttons button)
+        {
+            return (GetVirtualButtons() & button) == button;
+        }
+
+        /// <summary>
+        /// Determines whether specified input device buttons are released (not pressed) in this GamePadState.
+        /// </summary>
+        /// <returns><c>true</c>, if button was released (not pressed), <c>false</c> otherwise.</returns>
+        /// <param name="button">Buttons to query. Specify a single button, or combine multiple buttons using a bitwise OR operation.</param>
+        public bool IsButtonUp(Buttons button)
+        {
+            return (GetVirtualButtons() & button) != button;
+        }
+
+        /// <summary>
+        /// Determines whether a specified instance of <see cref="Microsoft.Xna.Framework.Input.GamePadState"/> is equal
+        /// to another specified <see cref="Microsoft.Xna.Framework.Input.GamePadState"/>.
+        /// </summary>
+        /// <param name="left">The first <see cref="Microsoft.Xna.Framework.Input.GamePadState"/> to compare.</param>
+        /// <param name="right">The second <see cref="Microsoft.Xna.Framework.Input.GamePadState"/> to compare.</param>
+        /// <returns><c>true</c> if <c>left</c> and <c>right</c> are equal; otherwise, <c>false</c>.</returns>
+        public static bool operator ==(GamePadState left, GamePadState right)
+        {
+            return (left.IsConnected == right.IsConnected) &&
+                (left.PacketNumber == right.PacketNumber) &&
+                (left.Buttons == right.Buttons) &&
+                (left.DPad == right.DPad) &&
+                (left.ThumbSticks == right.ThumbSticks) &&
+                (left.Triggers == right.Triggers);
+        }
+
+        /// <summary>
+        /// Determines whether a specified instance of <see cref="Microsoft.Xna.Framework.Input.GamePadState"/> is not
+        /// equal to another specified <see cref="Microsoft.Xna.Framework.Input.GamePadState"/>.
+        /// </summary>
+        /// <param name="left">The first <see cref="Microsoft.Xna.Framework.Input.GamePadState"/> to compare.</param>
+        /// <param name="right">The second <see cref="Microsoft.Xna.Framework.Input.GamePadState"/> to compare.</param>
+        /// <returns><c>true</c> if <c>left</c> and <c>right</c> are not equal; otherwise, <c>false</c>.</returns>
+        public static bool operator !=(GamePadState left, GamePadState right)
+        {
+            return !(left == right);
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="object"/> is equal to the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadState"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="object"/> to compare with the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadState"/>.</param>
+        /// <returns><c>true</c> if the specified <see cref="object"/> is equal to the current
+        /// <see cref="T:Microsoft.Xna.Framework.Input.GamePadState"/>; otherwise, <c>false</c>.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is GamePadState) && (this == (GamePadState)obj);
+        }
+
+        /// <summary>
+        /// Serves as a hash function for a <see cref="T:Microsoft.Xna.Framework.Input.GamePadState"/> object.
+        /// </summary>
+        /// <returns>A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a
+        /// hash table.</returns>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hash = PacketNumber;
+                hash = (hash * 397) ^ Buttons.GetHashCode();
+                hash = (hash * 397) ^ DPad.GetHashCode();
+                hash = (hash * 397) ^ ThumbSticks.GetHashCode();
+                hash = (hash * 397) ^ Triggers.GetHashCode();
+                return hash;
+            }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadState"/>.
+        /// </summary>
+        /// <returns>A <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadState"/>.</returns>
+        public override string ToString()
+        {
+            if (!IsConnected)
+                return "[GamePadState: IsConnected = 0]";
+
+            return "[GamePadState: IsConnected=" + (IsConnected ? "1" : "0") +
+                   ", PacketNumber=" + PacketNumber.ToString("00000") +
+                   ", Buttons=" + Buttons +
+                   ", DPad=" + DPad +
+                   ", ThumbSticks=" + ThumbSticks +
+                   ", Triggers=" + Triggers +
+                   "]";
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePadThumbSticks.cs b/MonoGame.Framework/Input/GamePadThumbSticks.cs
new file mode 100644
index 00000000000..0b56be5b5f1
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePadThumbSticks.cs
@@ -0,0 +1,192 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// A struct that represents the current stick (thumbstick) states for the controller.
+    /// </summary>
+    public struct GamePadThumbSticks
+    {
+#if DIRECTX && !WINDOWS_UAP
+        // XInput Xbox 360 Controller dead zones
+        // Dead zones are slighty different between left and right sticks, this may come from Microsoft usability tests
+        private const float leftThumbDeadZone = SharpDX.XInput.Gamepad.LeftThumbDeadZone / (float)short.MaxValue;
+        private const float rightThumbDeadZone = SharpDX.XInput.Gamepad.RightThumbDeadZone / (float)short.MaxValue;
+#else
+        // Default & SDL Xbox 360 Controller dead zones
+        // Based on the XInput constants
+        private const float leftThumbDeadZone = 0.24f;
+        private const float rightThumbDeadZone = 0.265f;
+#endif
+
+        internal readonly Buttons _virtualButtons;
+        private readonly Vector2 _left, _right;
+
+        /// <summary>
+        /// Gets a value indicating the position of the left stick (thumbstick). 
+        /// </summary>
+        /// <value>A <see cref="Vector2"/> indicating the current position of the left stick (thumbstick).</value>
+        public Vector2 Left
+        {
+            get { return _left; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating the position of the right stick (thumbstick). 
+        /// </summary>
+        /// <value>A <see cref="Vector2"/> indicating the current position of the right stick (thumbstick).</value>
+        public Vector2 Right
+        {
+            get { return _right; }
+        }
+
+        public GamePadThumbSticks(Vector2 leftPosition, Vector2 rightPosition)
+            : this(leftPosition, rightPosition, GamePadDeadZone.None, GamePadDeadZone.None)
+        {
+            
+        }
+
+        internal GamePadThumbSticks(Vector2 leftPosition, Vector2 rightPosition, GamePadDeadZone leftDeadZoneMode, GamePadDeadZone rightDeadZoneMode) : this()
+        {
+            // Apply dead zone
+            _left = ApplyDeadZone(leftDeadZoneMode, leftThumbDeadZone, leftPosition);
+            _right = ApplyDeadZone(rightDeadZoneMode, rightThumbDeadZone, rightPosition);
+
+            // VirtualButtons should always behave like deadzone is IndependentAxes. 
+            // This is consistent with XNA behaviour and generally most convenient (e.g. for menu navigation)
+            _virtualButtons = 0;
+
+            if (leftPosition.X < -leftThumbDeadZone)
+                _virtualButtons |= Buttons.LeftThumbstickLeft;
+            else if (leftPosition.X > leftThumbDeadZone)
+                _virtualButtons |= Buttons.LeftThumbstickRight;
+
+            if (leftPosition.Y < -leftThumbDeadZone)
+                _virtualButtons |= Buttons.LeftThumbstickDown;
+            else if (leftPosition.Y > leftThumbDeadZone)
+                _virtualButtons |= Buttons.LeftThumbstickUp;
+
+            if (rightPosition.X < -rightThumbDeadZone)
+                _virtualButtons |= Buttons.RightThumbstickLeft;
+            else if (rightPosition.X > rightThumbDeadZone)
+                _virtualButtons |= Buttons.RightThumbstickRight;
+
+            if (rightPosition.Y < -rightThumbDeadZone)
+                _virtualButtons |= Buttons.RightThumbstickDown;
+            else if (rightPosition.Y > rightThumbDeadZone)
+                _virtualButtons |= Buttons.RightThumbstickUp;
+        }
+
+        private Vector2 ApplyDeadZone(GamePadDeadZone deadZoneMode, float deadZone, Vector2 thumbstickPosition)
+        {
+            // XNA applies dead zones before rounding/clamping values. The public ctor does not allow this because the dead zone must be known before
+
+            // Apply dead zone
+            switch (deadZoneMode)
+            {
+                case GamePadDeadZone.None:
+                    break;
+                case GamePadDeadZone.IndependentAxes:
+                    thumbstickPosition = ExcludeIndependentAxesDeadZone(thumbstickPosition, deadZone);
+                    break;
+                case GamePadDeadZone.Circular:
+                    thumbstickPosition = ExcludeCircularDeadZone(thumbstickPosition, deadZone);
+                    break;
+            }
+
+            // Apply clamp
+            if (deadZoneMode == GamePadDeadZone.Circular)
+            {
+                if (thumbstickPosition.LengthSquared() > 1f)
+                    thumbstickPosition.Normalize();
+            }
+            else
+            {
+                thumbstickPosition = new Vector2(MathHelper.Clamp(thumbstickPosition.X, -1f, 1f), MathHelper.Clamp(thumbstickPosition.Y, -1f, 1f));
+            }
+
+            return thumbstickPosition;
+        }
+
+        private Vector2 ExcludeIndependentAxesDeadZone(Vector2 value, float deadZone)
+        {
+            return new Vector2(ExcludeAxisDeadZone(value.X, deadZone), ExcludeAxisDeadZone(value.Y, deadZone));
+        }
+
+        private float ExcludeAxisDeadZone(float value, float deadZone)
+        {
+            if (value < -deadZone)
+                value += deadZone;
+            else if (value > deadZone)
+                value -= deadZone;
+            else
+                return 0f;
+            return value / (1f - deadZone);
+        }
+
+        private Vector2 ExcludeCircularDeadZone(Vector2 value, float deadZone)
+        {
+            var originalLength = value.Length();
+            if (originalLength <= deadZone)
+                return Vector2.Zero;
+            var newLength = (originalLength - deadZone) / (1f - deadZone);
+            return value * (newLength / originalLength);
+        }
+
+        /// <summary>
+        /// Determines whether two specified instances of <see cref="GamePadThumbSticks"/> are equal.
+        /// </summary>
+        /// <param name="left">The first object to compare.</param>
+        /// <param name="right">The second object to compare.</param>
+        /// <returns>true if <paramref name="left"/> and <paramref name="right"/> are equal; otherwise, false.</returns>
+        public static bool operator ==(GamePadThumbSticks left, GamePadThumbSticks right)
+        {
+            return (left.Left == right.Left) && (left.Right == right.Right);
+        }
+
+        /// <summary>
+        /// Determines whether two specified instances of <see cref="GamePadThumbSticks"/> are not equal.
+        /// </summary>
+        /// <param name="left">The first object to compare.</param>
+        /// <param name="right">The second object to compare.</param>
+        /// <returns>true if <paramref name="left"/> and <paramref name="right"/> are not equal; otherwise, false.</returns>
+        public static bool operator !=(GamePadThumbSticks left, GamePadThumbSticks right)
+        {
+            return !(left == right);
+        }
+
+        /// <summary>
+        /// Returns a value indicating whether this instance is equal to a specified object.
+        /// </summary>
+        /// <param name="obj">An object to compare to this instance.</param>
+        /// <returns>true if <paramref name="obj"/> is a <see cref="GamePadThumbSticks"/> and has the same value as this instance; otherwise, false.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is GamePadThumbSticks) && (this == (GamePadThumbSticks)obj);
+        }
+
+        /// <summary>
+        /// Serves as a hash function for a <see cref="T:Microsoft.Xna.Framework.Input.GamePadThumbSticks"/> object.
+        /// </summary>
+        /// <returns>A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a
+        /// hash table.</returns>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (Left.GetHashCode() * 397) ^ Right.GetHashCode();
+            }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadThumbSticks"/>.
+        /// </summary>
+        /// <returns>A <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadThumbSticks"/>.</returns>
+        public override string ToString()
+        {
+            return "[GamePadThumbSticks: Left=" + Left + ", Right=" + Right + "]";
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePadTriggers.cs b/MonoGame.Framework/Input/GamePadTriggers.cs
new file mode 100644
index 00000000000..d700379215c
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePadTriggers.cs
@@ -0,0 +1,89 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// A struct that countains information on the left and the right trigger buttons.
+    /// </summary>
+    public struct GamePadTriggers
+    {
+        /// <summary>
+        /// Gets the position of the left trigger.
+        /// </summary>
+        /// <value>A value from 0.0f to 1.0f representing left trigger.</value>
+        public float Left { get; private set; }
+
+        /// <summary>
+        /// Gets the position of the right trigger.
+        /// </summary>
+        /// <value>A value from 0.0f to 1.0f representing right trigger.</value>
+        public float Right { get; private set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:Microsoft.Xna.Framework.Input.GamePadTriggers"/> struct.
+        /// </summary>
+        /// <param name="leftTrigger">The position of the left trigger, the value will get clamped between 0.0f and 1.0f.</param>
+        /// <param name="rightTrigger">The position of the right trigger, the value will get clamped between 0.0f and 1.0f.</param>
+        public GamePadTriggers(float leftTrigger, float rightTrigger) : this()
+        {
+            Left = MathHelper.Clamp(leftTrigger, 0f, 1f);
+            Right = MathHelper.Clamp(rightTrigger, 0f, 1f);
+        }
+
+        /// <summary>
+        /// Determines whether two specified instances of <see cref="GamePadTriggers"/> are equal.
+        /// </summary>
+        /// <param name="left">The first object to compare.</param>
+        /// <param name="right">The second object to compare.</param>
+        /// <returns>true if <paramref name="left"/> and <paramref name="right"/> are equal; otherwise, false.</returns>
+        public static bool operator ==(GamePadTriggers left, GamePadTriggers right)
+        {
+            return (left.Left == right.Left) && (left.Right == right.Right);
+        }
+
+        /// <summary>
+        /// Determines whether two specified instances of <see cref="GamePadTriggers"/> are not equal.
+        /// </summary>
+        /// <param name="left">The first object to compare.</param>
+        /// <param name="right">The second object to compare.</param>
+        /// <returns>true if <paramref name="left"/> and <paramref name="right"/> are not equal; otherwise, false.</returns>
+        public static bool operator !=(GamePadTriggers left, GamePadTriggers right)
+        {
+            return !(left == right);
+        }
+
+        /// <summary>
+        /// Returns a value indicating whether this instance is equal to a specified object.
+        /// </summary>
+        /// <param name="obj">An object to compare to this instance.</param>
+        /// <returns>true if <paramref name="obj"/> is a <see cref="GamePadTriggers"/> and has the same value as this instance; otherwise, false.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is GamePadTriggers) && (this == (GamePadTriggers)obj);
+        }
+
+        /// <summary>
+        /// Serves as a hash function for a <see cref="T:Microsoft.Xna.Framework.Input.GamePadTriggers"/> object.
+        /// </summary>
+        /// <returns>A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a
+        /// hash table.</returns>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (Left.GetHashCode() * 397) ^ Right.GetHashCode();
+            }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadTriggers"/>.
+        /// </summary>
+        /// <returns>A <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.GamePadTriggers"/>.</returns>
+        public override string ToString()
+        {
+            return "[GamePadTriggers: Left=" + Left + ", Right=" + Right + "]";
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/GamePadType.cs b/MonoGame.Framework/Input/GamePadType.cs
new file mode 100644
index 00000000000..39249f5eea5
--- /dev/null
+++ b/MonoGame.Framework/Input/GamePadType.cs
@@ -0,0 +1,62 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Defines a type of gamepad.
+    /// </summary>
+    public enum GamePadType
+    {
+        /// <summary>
+        /// Unknown.
+        /// </summary>
+        Unknown,
+
+        /// <summary>
+        /// GamePad is the XBOX controller.
+        /// </summary>
+        GamePad,
+
+        /// <summary>
+        /// GamePad is a wheel.
+        /// </summary>
+        Wheel,
+
+        /// <summary>
+        /// GamePad is an arcade stick.
+        /// </summary>
+        ArcadeStick,
+
+        /// <summary>
+        /// GamePad is a flight stick.
+        /// </summary>
+        FlightStick,
+
+        /// <summary>
+        /// GamePad is a dance pad.
+        /// </summary>
+        DancePad,
+
+        /// <summary>
+        /// GamePad is a guitar.
+        /// </summary>
+        Guitar,
+
+        /// <summary>
+        /// GamePad is an alternate guitar.
+        /// </summary>
+        AlternateGuitar,
+
+        /// <summary>
+        /// GamePad is a drum kit.
+        /// </summary>
+        DrumKit,
+
+        /// <summary>
+        /// GamePad is a big button pad.
+        /// </summary>
+        BigButtonPad = 768
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Input/GamepadUtil.Web.cs b/MonoGame.Framework/Input/GamepadUtil.Web.cs
new file mode 100644
index 00000000000..eb16d28abfb
--- /dev/null
+++ b/MonoGame.Framework/Input/GamepadUtil.Web.cs
@@ -0,0 +1,97 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    internal class ButtonType
+    {
+        public bool button { get; set; }
+        public int index { get; set; }
+    }
+
+    internal class GamepadTranslator
+    {
+        Dictionary<string, ButtonType> Data;
+
+        public GamepadTranslator(string config)
+        {
+            Data = new Dictionary<string, ButtonType>();
+            var split = config.Split(',');
+
+            for (int i = 1; i < split.Length; i++)
+            {
+                var split2 = split[i].Split(':');
+                var btype = new ButtonType()
+                    {
+                        button = (split2[1][0] == 'b'),
+                        index = Convert.ToInt32(split2[1].Substring(1))
+                    };
+                
+                Data.Add(split2[0], btype);
+            }
+        }
+
+        public ButtonType Read(string button)
+        {
+            return Data.ContainsKey(button) ? Data[button] : new ButtonType() { index = -1 };
+        }
+
+        public bool ButtonPressed(string button, JoystickState state)
+        {
+            var type = Read(button);
+
+            if (type.index != -1)
+            {
+                if (type.button)
+                    return state.Buttons[type.index] == ButtonState.Pressed;
+                else
+                    return state.Axes[type.index] == 1 || state.Axes[type.index] == -1;
+            }
+
+            return false;
+        }
+
+        public float AxisPressed(string axis, JoystickState state)
+        {
+            var type = Read(axis);
+            return type.index != -1 ? state.Axes[type.index] : 0f;
+        }
+
+        public bool DpadPressed(string dpad, JoystickState state)
+        {
+            var type = Read(dpad);
+
+            if (type.index != -1)
+            {
+                if (type.button)
+                    return state.Buttons[type.index] == ButtonState.Pressed;
+                else if(dpad == "dpright" || dpad == "dpdown")
+                    return state.Axes[type.index] == 1;
+                else
+                    return state.Axes[type.index] == -1;
+            }
+
+            return false;
+        }
+
+        public float TriggerPressed(string trigger, JoystickState state)
+        {
+            var type = Read(trigger);
+
+            if (type.index != -1)
+            {
+                if (type.button)
+                    return (state.Buttons[type.index] == ButtonState.Pressed) ? 1f : 0f;
+                else
+                    return Math.Max(state.Axes[type.index], 0f);
+            }
+
+            return 0f;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Input/Joystick.Default.cs b/MonoGame.Framework/Input/Joystick.Default.cs
new file mode 100644
index 00000000000..0b2b6d51c73
--- /dev/null
+++ b/MonoGame.Framework/Input/Joystick.Default.cs
@@ -0,0 +1,37 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    static partial class Joystick
+    {
+        private const bool PlatformIsSupported = false;
+
+        private static JoystickCapabilities PlatformGetCapabilities(int index)
+        {
+            return new JoystickCapabilities()
+            {
+                IsConnected = false,
+                IsGamepad = false,
+                AxisCount = 0,
+                ButtonCount = 0,
+                HatCount = 0
+            };
+        }
+
+        private static JoystickState PlatformGetState(int index)
+        {
+            return new JoystickState()
+            {
+                IsConnected = false,
+                Axes = new int[0],
+                Buttons = new ButtonState[0],
+                Hats = new JoystickHat[0]
+            };
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Input/Joystick.SDL.cs b/MonoGame.Framework/Input/Joystick.SDL.cs
new file mode 100644
index 00000000000..cba7ea07a9b
--- /dev/null
+++ b/MonoGame.Framework/Input/Joystick.SDL.cs
@@ -0,0 +1,123 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    static partial class Joystick
+    {
+        internal static Dictionary<int, IntPtr> Joysticks = new Dictionary<int, IntPtr>();
+
+        internal static void AddDevice(int deviceId)
+        {
+            var jdevice = Sdl.Joystick.Open(deviceId);
+            var id = 0;
+
+            while (Joysticks.ContainsKey(id))
+                id++;
+
+            Joysticks.Add(id, jdevice);
+
+            if (Sdl.GameController.IsGameController(deviceId) == 1)
+                GamePad.AddDevice(deviceId);
+        }
+
+        internal static void RemoveDevice(int instanceid)
+        {
+            foreach (KeyValuePair<int, IntPtr> entry in Joysticks)
+            {
+                if (Sdl.Joystick.InstanceID(entry.Value) == instanceid)
+                {
+                    Sdl.Joystick.Close(Joysticks[entry.Key]);
+                    Joysticks.Remove(entry.Key);
+                    break;
+                }
+            }
+        }
+
+        internal static void CloseDevices()
+        {
+            GamePad.CloseDevices();
+
+            foreach (var entry in Joysticks)
+                Sdl.Joystick.Close(entry.Value);
+
+            Joysticks.Clear ();
+        }
+
+        private const bool PlatformIsSupported = true;
+
+        private static JoystickCapabilities PlatformGetCapabilities(int index)
+        {
+            if (!Joysticks.ContainsKey(index))
+                return new JoystickCapabilities
+                {
+                    IsConnected = false,
+                    Identifier = "",
+                    IsGamepad = false,
+                    AxisCount = 0,
+                    ButtonCount = 0,
+                    HatCount = 0
+                };
+
+            var jdevice = Joysticks[index];
+            return new JoystickCapabilities
+            {
+                IsConnected = true,
+                Identifier = Sdl.Joystick.GetGUID(jdevice).ToString(),
+                IsGamepad = (Sdl.GameController.IsGameController(index) == 1),
+                AxisCount = Sdl.Joystick.NumAxes(jdevice),
+                ButtonCount = Sdl.Joystick.NumButtons(jdevice),
+                HatCount = Sdl.Joystick.NumHats(jdevice)
+            };
+        }
+
+        private static JoystickState PlatformGetState(int index)
+        {
+            if (!Joysticks.ContainsKey(index))
+                return new JoystickState
+                {
+                    IsConnected = false,
+                    Axes = new int[0],
+                    Buttons = new ButtonState[0],
+                    Hats = new JoystickHat[0]
+                };
+
+            var jcap = PlatformGetCapabilities(index);
+            var jdevice = Joysticks[index];
+
+            var axes = new int[jcap.AxisCount];
+            for (var i = 0; i < axes.Length; i++)
+                axes[i] = Sdl.Joystick.GetAxis(jdevice, i);
+
+            var buttons = new ButtonState[jcap.ButtonCount];
+            for (var i = 0; i < buttons.Length; i++)
+                buttons[i] = (Sdl.Joystick.GetButton(jdevice, i) == 0) ? ButtonState.Released : ButtonState.Pressed;
+
+            var hats = new JoystickHat[jcap.HatCount];
+            for (var i = 0; i < hats.Length; i++)
+            {
+                var hatstate = Sdl.Joystick.GetHat(jdevice, i);
+
+                hats[i] = new JoystickHat
+                {
+                    Up = hatstate.HasFlag(Sdl.Joystick.Hat.Up) ? ButtonState.Pressed : ButtonState.Released,
+                    Down = hatstate.HasFlag(Sdl.Joystick.Hat.Down) ? ButtonState.Pressed : ButtonState.Released,
+                    Left = hatstate.HasFlag(Sdl.Joystick.Hat.Left) ? ButtonState.Pressed : ButtonState.Released,
+                    Right = hatstate.HasFlag(Sdl.Joystick.Hat.Right) ? ButtonState.Pressed : ButtonState.Released
+                };
+            }
+
+            return new JoystickState
+            {
+                IsConnected = true,
+                Axes = axes,
+                Buttons = buttons,
+                Hats = hats
+            };
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/Joystick.Web.cs b/MonoGame.Framework/Input/Joystick.Web.cs
new file mode 100644
index 00000000000..a6271a59669
--- /dev/null
+++ b/MonoGame.Framework/Input/Joystick.Web.cs
@@ -0,0 +1,90 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using JSIL;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    static partial class Joystick
+    {
+        private const bool PlatformIsSupported = true;
+
+        internal static bool TrackEvents = false;
+
+        private static JoystickCapabilities PlatformGetCapabilities(int index)
+        {
+            bool connected = false;
+            string id = "";
+            int axiscount = 0;
+            int buttoncount = 0;
+
+            var navigator = Builtins.Global["navigator"];
+            var gamepads = navigator.getGamepads ? navigator.getGamepads() : navigator.webkitGetGamepads();
+
+            if (gamepads.length > index)
+            {
+                if (gamepads[index])
+                {
+                    connected = true;
+                    id = gamepads[index].id;
+                    axiscount = gamepads[index].axes.length;
+                    buttoncount = gamepads[index].buttons.length;
+                }
+            }
+
+            return new JoystickCapabilities()
+            {
+                IsConnected = connected,
+                Identifier = id,
+                AxisCount = axiscount,
+                ButtonCount = buttoncount,
+                HatCount = 0
+            };
+        }
+
+        private static JoystickState PlatformGetState(int index)
+        {
+            var connected = false;
+            var axes = new int[0];
+            var buttons = new ButtonState[0];
+
+            var navigator = Builtins.Global["navigator"];
+            var gamepads = navigator.getGamepads ? navigator.getGamepads() : navigator.webkitGetGamepads();
+
+            if (gamepads.length > index)
+            {
+                if (gamepads[index])
+                {
+                    connected = true;
+
+                    var axescount = gamepads[index].axes.length;
+                    axes = new int[gamepads[index].axes.length];
+
+                    for (int i = 0; i < axescount; i++)
+                        axes[i] = gamepads[index].axes[i];
+
+                    var buttoncount = gamepads[index].buttons.length;
+                    buttons = new ButtonState[buttoncount];
+
+                    for (int i = 0; i < buttoncount; i++)
+                    {
+                        if (gamepads[index].buttons[i].pressed)
+                            buttons[i] = ButtonState.Pressed;
+                        else
+                            buttons[i] = ButtonState.Released;
+                    }
+                }
+            }
+
+            return new JoystickState()
+            {
+                IsConnected = connected,
+                Axes = axes,
+                Buttons = buttons,
+                Hats = new JoystickHat[0]
+            };
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/Joystick.cs b/MonoGame.Framework/Input/Joystick.cs
new file mode 100644
index 00000000000..e0ee0c63d1c
--- /dev/null
+++ b/MonoGame.Framework/Input/Joystick.cs
@@ -0,0 +1,41 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary> 
+    /// Allows interaction with joysticks. Unlike <see cref="GamePad"/> the number of Buttons/Axes/DPads is not limited.
+    /// </summary>
+    public static partial class Joystick
+    {
+        /// <summary>
+        /// Gets a value indicating whether the current platform supports reading raw joystick data.
+        /// </summary>
+        /// <value><c>true</c> if the current platform supports reading raw joystick data; otherwise, <c>false</c>.</value>
+        public static bool IsSupported
+        {
+            get { return PlatformIsSupported; }
+        }
+
+        /// <summary>
+        /// Gets the capabilites of the joystick.
+        /// </summary>
+        /// <param name="index">Index of the joystick you want to access.</param>
+        /// <returns>The capabilites of the joystick.</returns>
+        public static JoystickCapabilities GetCapabilities(int index)
+        {
+            return PlatformGetCapabilities(index);
+        }
+
+        /// <summary>
+        /// Gets the current state of the joystick.
+        /// </summary>
+        /// <param name="index">Index of the joystick you want to access.</param>
+        /// <returns>The state of the joystick.</returns>
+        public static JoystickState GetState(int index)
+        {
+            return PlatformGetState(index);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/JoystickCapabilities.cs b/MonoGame.Framework/Input/JoystickCapabilities.cs
new file mode 100644
index 00000000000..14e2783b5a4
--- /dev/null
+++ b/MonoGame.Framework/Input/JoystickCapabilities.cs
@@ -0,0 +1,108 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Describes joystick capabilities.
+    /// </summary>
+    public struct JoystickCapabilities
+    {
+        /// <summary>
+        /// Gets a value indicating whether the joystick is connected.
+        /// </summary>
+        /// <value><c>true</c> if the joystick is connected; otherwise, <c>false</c>.</value>
+        public bool IsConnected { get; internal set; }
+
+        /// <summary>
+        /// Gets the unique identifier of the joystick.
+        /// </summary>
+        /// <value>String representing the unique identifier of the joystick.</value>
+        public string Identifier { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating if the joystick is a gamepad.
+        /// </summary>
+        /// <value><c>true</c> if the joystick is a gamepad; otherwise, <c>false</c>.</value>
+        public bool IsGamepad { get; internal set; }
+
+        /// <summary>
+        /// Gets the axis count.
+        /// </summary>
+        /// <value>The number of axes that the joystick possesses.</value>
+        public int AxisCount { get; internal set; }
+
+        /// <summary>
+        /// Gets the button count.
+        /// </summary>
+        /// <value>The number of buttons that the joystick possesses.</value>
+        public int ButtonCount { get; internal set; }
+
+        /// <summary>
+        /// Gets the hat count.
+        /// </summary>
+        /// <value>The number of hats/dpads that the joystick possesses.</value>
+        public int HatCount { get; internal set; }
+
+        /// <summary>
+        /// Determines whether a specified instance of <see cref="Microsoft.Xna.Framework.Input.JoystickCapabilities"/>
+        /// is equal to another specified <see cref="Microsoft.Xna.Framework.Input.JoystickCapabilities"/>.
+        /// </summary>
+        /// <param name="left">The first <see cref="Microsoft.Xna.Framework.Input.JoystickCapabilities"/> to compare.</param>
+        /// <param name="right">The second <see cref="Microsoft.Xna.Framework.Input.JoystickCapabilities"/> to compare.</param>
+        /// <returns><c>true</c> if <c>left</c> and <c>right</c> are equal; otherwise, <c>false</c>.</returns>
+        public static bool operator ==(JoystickCapabilities left, JoystickCapabilities right)
+        {
+            return left.IsConnected == right.IsConnected &&
+               left.Identifier == right.Identifier &&
+               left.IsGamepad == right.IsGamepad &&
+               left.AxisCount == right.AxisCount &&
+               left.ButtonCount == right.ButtonCount &&
+               left.HatCount == right.HatCount;
+        }
+
+        /// <summary>
+        /// Determines whether a specified instance of <see cref="Microsoft.Xna.Framework.Input.JoystickCapabilities"/>
+        /// is not equal to another specified <see cref="Microsoft.Xna.Framework.Input.JoystickCapabilities"/>.
+        /// </summary>
+        /// <param name="left">The first <see cref="Microsoft.Xna.Framework.Input.JoystickCapabilities"/> to compare.</param>
+        /// <param name="right">The second <see cref="Microsoft.Xna.Framework.Input.JoystickCapabilities"/> to compare.</param>
+        /// <returns><c>true</c> if <c>left</c> and <c>right</c> are not equal; otherwise, <c>false</c>.</returns>
+        public static bool operator !=(JoystickCapabilities left, JoystickCapabilities right)
+        {
+            return !(left == right);
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="object"/> is equal to the current <see cref="T:Microsoft.Xna.Framework.Input.JoystickCapabilities"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="object"/> to compare with the current <see cref="T:Microsoft.Xna.Framework.Input.JoystickCapabilities"/>.</param>
+        /// <returns><c>true</c> if the specified <see cref="object"/> is equal to the current
+        /// <see cref="T:Microsoft.Xna.Framework.Input.JoystickCapabilities"/>; otherwise, <c>false</c>.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is JoystickCapabilities) && (this == (JoystickCapabilities)obj);
+        }
+
+        /// <summary>
+        /// Serves as a hash function for a <see cref="T:Microsoft.Xna.Framework.Input.JoystickCapabilities"/> object.
+        /// </summary>
+        /// <returns>A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a
+        /// hash table.</returns>
+        public override int GetHashCode()
+        {
+            return Identifier.GetHashCode();
+        }
+
+        /// <summary>
+        /// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.JoystickCapabilities"/>.
+        /// </summary>
+        /// <returns>A <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.JoystickCapabilities"/>.</returns>
+        public override string ToString()
+        {
+            return "[JoystickCapabilities: IsConnected=" + IsConnected + ", Identifier=" + Identifier + ", IsGamepad=" + IsGamepad + " , AxisCount=" + AxisCount + ", ButtonCount=" + ButtonCount + ", HatCount=" + HatCount + "]";
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Input/JoystickHat.cs b/MonoGame.Framework/Input/JoystickHat.cs
new file mode 100644
index 00000000000..80960918e29
--- /dev/null
+++ b/MonoGame.Framework/Input/JoystickHat.cs
@@ -0,0 +1,105 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Describes joystick hat state.
+    /// </summary>
+    public struct JoystickHat
+    {
+        /// <summary>
+        /// Gets if joysticks hat "down" is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the button is pressed otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState Down { get; internal set; }
+
+        /// <summary>
+        /// Gets if joysticks hat "left" is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the button is pressed otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState Left { get; internal set; }
+
+        /// <summary>
+        /// Gets if joysticks hat "right" is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the button is pressed otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState Right { get; internal set; }
+
+        /// <summary>
+        /// Gets if joysticks hat "up" is pressed.
+        /// </summary>
+        /// <value><see cref="ButtonState.Pressed"/> if the button is pressed otherwise, <see cref="ButtonState.Released"/>.</value>
+        public ButtonState Up { get; internal set; }
+
+        /// <summary>
+        /// Determines whether a specified instance of <see cref="Microsoft.Xna.Framework.Input.JoystickHat"/> is equal
+        /// to another specified <see cref="Microsoft.Xna.Framework.Input.JoystickHat"/>.
+        /// </summary>
+        /// <param name="left">The first <see cref="Microsoft.Xna.Framework.Input.JoystickHat"/> to compare.</param>
+        /// <param name="right">The second <see cref="Microsoft.Xna.Framework.Input.JoystickHat"/> to compare.</param>
+        /// <returns><c>true</c> if <c>left</c> and <c>right</c> are equal; otherwise, <c>false</c>.</returns>
+        public static bool operator ==(JoystickHat left, JoystickHat right)
+        {
+            return (left.Down == right.Down) &&
+                (left.Left == right.Left) &&
+                (left.Right == right.Right) &&
+                (left.Up == right.Up);
+        }
+
+        /// <summary>
+        /// Determines whether a specified instance of <see cref="Microsoft.Xna.Framework.Input.JoystickHat"/> is not
+        /// equal to another specified <see cref="Microsoft.Xna.Framework.Input.JoystickHat"/>.
+        /// </summary>
+        /// <param name="left">The first <see cref="Microsoft.Xna.Framework.Input.JoystickHat"/> to compare.</param>
+        /// <param name="right">The second <see cref="Microsoft.Xna.Framework.Input.JoystickHat"/> to compare.</param>
+        /// <returns><c>true</c> if <c>left</c> and <c>right</c> are not equal; otherwise, <c>false</c>.</returns>
+        public static bool operator !=(JoystickHat left, JoystickHat right)
+        {
+            return !(left == right);
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="object"/> is equal to the current <see cref="T:Microsoft.Xna.Framework.Input.JoystickHat"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="object"/> to compare with the current <see cref="T:Microsoft.Xna.Framework.Input.JoystickHat"/>.</param>
+        /// <returns><c>true</c> if the specified <see cref="object"/> is equal to the current
+        /// <see cref="T:Microsoft.Xna.Framework.Input.JoystickHat"/>; otherwise, <c>false</c>.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is JoystickHat) && (this == (JoystickHat)obj);
+        }
+
+        /// <summary>
+        /// Serves as a hash function for a <see cref="T:Microsoft.Xna.Framework.Input.JoystickHat"/> object.
+        /// </summary>
+        /// <returns>A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a
+        /// hash table.</returns>
+        public override int GetHashCode()
+        {
+            var hash = 0;
+
+            if (Left == ButtonState.Pressed)
+                hash |= (1 << 3);
+            if (Up == ButtonState.Pressed)
+                hash |= (1 << 2);
+            if (Right == ButtonState.Pressed)
+                hash |= (1 << 1);
+            if (Down == ButtonState.Pressed)
+                hash |= (1 << 0);
+
+            return hash;
+        }
+
+        /// <summary>
+        /// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.JoystickHat"/> in a format of 0000 where each number represents a boolean value of each respecting object property: Left, Up, Right, Down.
+        /// </summary>
+        /// <returns>A <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.JoystickHat"/>.</returns>
+        public override string ToString()
+        {
+            return "" + (int)Left + (int)Up + (int)Right + (int)Down;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Input/JoystickState.cs b/MonoGame.Framework/Input/JoystickState.cs
new file mode 100644
index 00000000000..efb03353340
--- /dev/null
+++ b/MonoGame.Framework/Input/JoystickState.cs
@@ -0,0 +1,135 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Linq;
+using System.Text;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Describes current joystick state.
+    /// </summary>
+    public struct JoystickState
+    {
+        /// <summary>
+        /// Gets a value indicating whether the joystick is connected.
+        /// </summary>
+        /// <value><c>true</c> if the joystick is connected; otherwise, <c>false</c>.</value>
+        public bool IsConnected { get; internal set; }
+
+        /// <summary>
+        /// Gets the joystick axis values.
+        /// </summary>
+        /// <value>An array list of ints that indicate axis values.</value>
+        public int[] Axes { get; internal set; }
+
+        /// <summary>
+        /// Gets the joystick button values.
+        /// </summary>
+        /// <value>An array list of ButtonState that indicate button values.</value>
+        public ButtonState[] Buttons { get; internal set; }
+
+        /// <summary>
+        /// Gets the joystick hat values.
+        /// </summary>
+        /// <value>An array list of <see cref="JoystickHat"/> that indicate hat values.</value>
+        public JoystickHat[] Hats{ get; internal set; }
+
+        /// <summary>
+        /// Determines whether a specified instance of <see cref="Microsoft.Xna.Framework.Input.JoystickState"/> is
+        /// equal to another specified <see cref="Microsoft.Xna.Framework.Input.JoystickState"/>.
+        /// </summary>
+        /// <param name="left">The first <see cref="Microsoft.Xna.Framework.Input.JoystickState"/> to compare.</param>
+        /// <param name="right">The second <see cref="Microsoft.Xna.Framework.Input.JoystickState"/> to compare.</param>
+        /// <returns><c>true</c> if <c>left</c> and <c>right</c> are equal; otherwise, <c>false</c>.</returns>
+        public static bool operator ==(JoystickState left, JoystickState right)
+        {
+            return left.IsConnected == right.IsConnected &&
+               left.Axes.SequenceEqual(right.Axes) &&
+               left.Buttons.SequenceEqual(right.Buttons) &&
+               left.Hats.SequenceEqual(right.Hats);
+        }
+
+        /// <summary>
+        /// Determines whether a specified instance of <see cref="Microsoft.Xna.Framework.Input.JoystickState"/> is not
+        /// equal to another specified <see cref="Microsoft.Xna.Framework.Input.JoystickState"/>.
+        /// </summary>
+        /// <param name="left">The first <see cref="Microsoft.Xna.Framework.Input.JoystickState"/> to compare.</param>
+        /// <param name="right">The second <see cref="Microsoft.Xna.Framework.Input.JoystickState"/> to compare.</param>
+        /// <returns><c>true</c> if <c>left</c> and <c>right</c> are not equal; otherwise, <c>false</c>.</returns>
+        public static bool operator !=(JoystickState left, JoystickState right)
+        {
+            return !(left == right);
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="object"/> is equal to the current <see cref="T:Microsoft.Xna.Framework.Input.JoystickState"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="object"/> to compare with the current <see cref="T:Microsoft.Xna.Framework.Input.JoystickState"/>.</param>
+        /// <returns><c>true</c> if the specified <see cref="object"/> is equal to the current
+        /// <see cref="T:Microsoft.Xna.Framework.Input.JoystickState"/>; otherwise, <c>false</c>.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is JoystickState) && (this == (JoystickState)obj);
+        }
+
+        /// <summary>
+        /// Serves as a hash function for a <see cref="T:Microsoft.Xna.Framework.Input.JoystickState"/> object.
+        /// </summary>
+        /// <returns>A hash code for this instance that is suitable for use in hashing algorithms and data structures such as a
+        /// hash table.</returns>
+        public override int GetHashCode()
+        {
+            var hash = 0;
+
+            if (IsConnected)
+            {
+                unchecked
+                {
+                    foreach (var axis in Axes)
+                        hash = (hash * 397) ^ axis;
+
+                    for (int i = 0; i < Buttons.Length; i++)
+                        hash = hash ^ ((int)Buttons[i] << (i % 32));
+
+                    foreach (var hat in Hats)
+                        hash = (hash * 397) ^ hat.GetHashCode();
+                }
+            }
+
+            return hash;
+        }
+
+        /// <summary>
+        /// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.JoystickState"/>.
+        /// </summary>
+        /// <returns>A <see cref="T:System.String"/> that represents the current <see cref="T:Microsoft.Xna.Framework.Input.JoystickState"/>.</returns>
+        public override string ToString()
+        {
+            var ret = new StringBuilder(54 - 2 + Axes.Length * 7 + Buttons.Length + Hats.Length * 5);
+            ret.Append("[JoystickState: IsConnected=" + (IsConnected ? 1 : 0));
+
+            if (IsConnected)
+            {
+                ret.Append(", Axes=");
+                foreach (var axis in Axes)
+                    ret.Append((axis > 0 ? "+" : "") + axis.ToString("00000") + " ");
+                ret.Length--;
+
+                ret.Append(", Buttons=");
+                foreach (var button in Buttons)
+                    ret.Append((int)button);
+
+                ret.Append(", Hats=");
+                foreach (var hat in Hats)
+                    ret.Append(hat + " ");
+                ret.Length--;
+            }
+
+            ret.Append("]");
+            return ret.ToString();
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Input/KeyState.cs b/MonoGame.Framework/Input/KeyState.cs
new file mode 100644
index 00000000000..66e351b6cf4
--- /dev/null
+++ b/MonoGame.Framework/Input/KeyState.cs
@@ -0,0 +1,58 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce, " "reproduction,  " "derivative works,  " and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3,  
+// each contributor grants you a non-exclusive, worldwide,  royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3,  
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make,  have made, use,  sell, offer for sale, import,  and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+namespace Microsoft.Xna.Framework.Input
+{
+	/// <summary>
+	/// Identifies the state of a keyboard key.
+	/// </summary>
+	public enum KeyState
+	{
+		/// <summary>
+		/// Key is released.
+		/// </summary>
+		Up,
+
+		/// <summary>
+		/// Key is pressed.
+		/// </summary>
+		Down,
+	}
+}
diff --git a/MonoGame.Framework/Input/Keyboard.Default.cs b/MonoGame.Framework/Input/Keyboard.Default.cs
new file mode 100644
index 00000000000..44c5ec5a3d5
--- /dev/null
+++ b/MonoGame.Framework/Input/Keyboard.Default.cs
@@ -0,0 +1,23 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class Keyboard
+    {
+        static List<Keys> _keys;
+
+        private static KeyboardState PlatformGetState()
+        {
+            return new KeyboardState(_keys);
+        }
+
+        internal static void SetKeys(List<Keys> keys)
+        {
+            _keys = keys;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/Keyboard.SDL.cs b/MonoGame.Framework/Input/Keyboard.SDL.cs
new file mode 100644
index 00000000000..fd00648ebcd
--- /dev/null
+++ b/MonoGame.Framework/Input/Keyboard.SDL.cs
@@ -0,0 +1,26 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class Keyboard
+    {
+        static List<Keys> _keys;
+
+        private static KeyboardState PlatformGetState()
+        {
+            var modifiers = Sdl.Keyboard.GetModState();
+            return new KeyboardState(_keys,
+                                     (modifiers & Sdl.Keyboard.Keymod.CapsLock) == Sdl.Keyboard.Keymod.CapsLock,
+                                     (modifiers & Sdl.Keyboard.Keymod.NumLock) == Sdl.Keyboard.Keymod.NumLock);
+        }
+
+        internal static void SetKeys(List<Keys> keys)
+        {
+            _keys = keys;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/Keyboard.WinRT.cs b/MonoGame.Framework/Input/Keyboard.WinRT.cs
new file mode 100644
index 00000000000..fad03c1cd63
--- /dev/null
+++ b/MonoGame.Framework/Input/Keyboard.WinRT.cs
@@ -0,0 +1,40 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class Keyboard
+    {   
+        static KeyboardState _keyboardState;
+        static KeyboardState _nextKeyboardState;
+
+        private static KeyboardState PlatformGetState()
+        {
+            return _keyboardState;
+        }
+
+        internal static void UpdateState()
+        {
+            _keyboardState = _nextKeyboardState;
+        }
+
+        internal static void SetKey(Keys key)
+        {
+            _nextKeyboardState.InternalSetKey(key);
+        }
+
+        internal static void ClearKey(Keys key)
+        {
+            _nextKeyboardState.InternalClearKey(key);
+        }
+                
+        internal static void Clear()
+        {
+            _nextKeyboardState.InternalClearAllKeys();
+        }
+
+    }
+}
diff --git a/MonoGame.Framework/Input/Keyboard.Windows.cs b/MonoGame.Framework/Input/Keyboard.Windows.cs
new file mode 100644
index 00000000000..07cc14cf46b
--- /dev/null
+++ b/MonoGame.Framework/Input/Keyboard.Windows.cs
@@ -0,0 +1,69 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class Keyboard
+    {
+        private static readonly byte[] DefinedKeyCodes;
+
+        private static readonly byte[] _keyState = new byte[256];
+        private static readonly List<Keys> _keys = new List<Keys>(10);
+
+        private static bool _isActive;
+
+        [DllImport("user32.dll")]
+        private static extern bool GetKeyboardState(byte[] lpKeyState);
+
+        private static readonly Predicate<Keys> IsKeyReleasedPredicate = key => IsKeyReleased((byte)key);
+
+        static Keyboard()
+        {
+            var definedKeys = Enum.GetValues(typeof(Keys));
+            var keyCodes = new List<byte>(Math.Min(definedKeys.Length, 255));
+            foreach (var key in definedKeys)
+            {
+                var keyCode = (int)key;
+                if ((keyCode >= 1) && (keyCode <= 255))
+                    keyCodes.Add((byte)keyCode);
+            }
+            DefinedKeyCodes = keyCodes.ToArray();
+        }
+
+        private static KeyboardState PlatformGetState()
+        {
+            if (_isActive && GetKeyboardState(_keyState))
+            {
+                _keys.RemoveAll(IsKeyReleasedPredicate);
+
+                foreach (var keyCode in DefinedKeyCodes)
+                {
+                    if (IsKeyReleased(keyCode))
+                        continue;
+                    var key = (Keys)keyCode;
+                    if (!_keys.Contains(key))
+                        _keys.Add(key);
+                }
+            }
+
+            return new KeyboardState(_keys, Console.CapsLock, Console.NumberLock);
+        }
+
+        private static bool IsKeyReleased(byte keyCode)
+        {
+            return ((_keyState[keyCode] & 0x80) == 0);
+        }
+
+        internal static void SetActive(bool isActive)
+        {
+            _isActive = isActive;
+            if (!_isActive)
+                _keys.Clear();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/Keyboard.cs b/MonoGame.Framework/Input/Keyboard.cs
new file mode 100644
index 00000000000..54b0ffd683a
--- /dev/null
+++ b/MonoGame.Framework/Input/Keyboard.cs
@@ -0,0 +1,34 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Allows getting keystrokes from keyboard.
+    /// </summary>
+	public static partial class Keyboard
+	{
+        /// <summary>
+        /// Returns the current keyboard state.
+        /// </summary>
+        /// <returns>Current keyboard state.</returns>
+		public static KeyboardState GetState()
+		{
+            return PlatformGetState();
+		}
+		
+        /// <summary>
+        /// Returns the current keyboard state for a given player.
+        /// </summary>
+        /// <param name="playerIndex">Player index of the keyboard.</param>
+        /// <returns>Current keyboard state.</returns>
+        [Obsolete("Use GetState() instead. In future versions this method can be removed.")]
+        public static KeyboardState GetState(PlayerIndex playerIndex)
+		{
+            return PlatformGetState();
+		}
+	}
+}
diff --git a/MonoGame.Framework/Input/KeyboardInput.Android.cs b/MonoGame.Framework/Input/KeyboardInput.Android.cs
new file mode 100644
index 00000000000..723200883f2
--- /dev/null
+++ b/MonoGame.Framework/Input/KeyboardInput.Android.cs
@@ -0,0 +1,64 @@
+using System.Threading.Tasks;
+using Android.App;
+using Android.Content;
+using Android.Widget;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class KeyboardInput
+    {
+        private static TaskCompletionSource<string> tcs;
+        private static AlertDialog alert;
+
+        private static Task<string> PlatformShow(string title, string description, string defaultText, bool usePasswordMode)
+        {
+            tcs = new TaskCompletionSource<string>();
+
+            Game.Activity.RunOnUiThread(() =>
+            {
+                alert = new AlertDialog.Builder(Game.Activity).Create();
+
+                alert.SetTitle(title);
+                alert.SetMessage(description);
+
+                var input = new EditText(Game.Activity) { Text = defaultText };
+
+                if (defaultText != null)
+                    input.SetSelection(defaultText.Length);
+
+                if (usePasswordMode)
+                    input.InputType = Android.Text.InputTypes.ClassText | Android.Text.InputTypes.TextVariationPassword;
+
+                alert.SetView(input);
+
+                alert.SetButton((int)DialogButtonType.Positive, "Ok", (sender, args) =>
+                {
+                    if (!tcs.Task.IsCompleted)
+                        tcs.SetResult(input.Text);
+                });
+
+                alert.SetButton((int)DialogButtonType.Negative, "Cancel", (sender, args) =>
+                {
+                    if (!tcs.Task.IsCompleted)
+                        tcs.SetResult(null);
+                });
+
+                alert.CancelEvent += (sender, args) =>
+                {
+                    if (!tcs.Task.IsCompleted)
+                        tcs.SetResult(null);
+                };
+
+                alert.Show();
+            });
+
+            return tcs.Task;
+        }
+
+        private static void PlatformCancel(string result)
+        {
+            alert.Dismiss();
+            tcs.SetResult(result);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/KeyboardInput.WinRT.cs b/MonoGame.Framework/Input/KeyboardInput.WinRT.cs
new file mode 100644
index 00000000000..9acad8df953
--- /dev/null
+++ b/MonoGame.Framework/Input/KeyboardInput.WinRT.cs
@@ -0,0 +1,764 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.Core;
+using Windows.System;
+using Windows.UI.Core;
+using Windows.UI.ViewManagement;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Controls.Primitives;
+using Windows.UI.Xaml.Input;
+using Windows.UI.Xaml.Media;
+using Windows.UI.Xaml.Media.Animation;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class KeyboardInput
+    {
+        private static readonly CoreDispatcher dispatcher;
+        private static TaskCompletionSource<string> tcs;
+        private static InputDialog inputDialog;
+
+        static KeyboardInput()
+        {
+            dispatcher = CoreApplication.MainView.CoreWindow.Dispatcher;
+        }
+
+        private static Task<string> PlatformShow(string title, string description, string defaultText, bool usePasswordMode)
+        {
+            tcs = new TaskCompletionSource<string>();
+            dispatcher.RunAsync(CoreDispatcherPriority.Normal,
+                async () =>
+                {
+                    inputDialog = new InputDialog();
+                    var result = await inputDialog.ShowAsync(title, description, defaultText, usePasswordMode);
+
+                    if (!tcs.Task.IsCompleted)
+                        tcs.SetResult(result);
+                });
+
+            return tcs.Task;
+        }
+
+        private static void PlatformCancel(string result)
+        {
+            dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () => await inputDialog.CloseAsync());
+
+            tcs.SetResult(result);
+        }
+    }
+
+    #region Keyboard Input UI
+    [TemplatePart(Name = LayoutRootPanelName, Type = typeof(Panel))]
+    [TemplatePart(Name = ContentBorderName, Type = typeof(Border))]
+    [TemplatePart(Name = InputTextBoxName, Type = typeof(TextBox))]
+    [TemplatePart(Name = TitleTextBlockName, Type = typeof(TextBlock))]
+    [TemplatePart(Name = TextTextBlockName, Type = typeof(TextBlock))]
+    [TemplatePart(Name = ButtonsPanelName, Type = typeof(Panel))]
+    [TemplateVisualState(GroupName = PopupStatesGroupName, Name = OpenPopupStateName)]
+    [TemplateVisualState(GroupName = PopupStatesGroupName, Name = ClosedPopupStateName)]
+    [StyleTypedProperty(Property = "ButtonStyle", StyleTargetType = typeof(ButtonBase))]
+    [StyleTypedProperty(Property = "TitleStyle", StyleTargetType = typeof(TextBlock))]
+    [StyleTypedProperty(Property = "TextStyle", StyleTargetType = typeof(TextBlock))]
+    [StyleTypedProperty(Property = "InputTextStyle", StyleTargetType = typeof(TextBox))]
+    [StyleTypedProperty(Property = "InputPasswordStyle", StyleTargetType = typeof(PasswordBox))]
+    sealed class InputDialog : Control
+    {
+        private const string PopupStatesGroupName = "PopupStates";
+        private const string OpenPopupStateName = "OpenPopupState";
+        private const string ClosedPopupStateName = "ClosedPopupState";
+
+        private const string LayoutRootPanelName = "LayoutRoot";
+        private const string ContentBorderName = "ContentBorder";
+        private const string InputTextBoxName = "InputTextBox";
+        private const string InputPasswordBoxName = "InputPasswordBox";
+        private const string TitleTextBlockName = "TitleTextBlock";
+        private const string TextTextBlockName = "TextTextBlock";
+        private const string ButtonsPanelName = "ButtonsPanel";
+
+        private const string VirtualKeyboardSlideStoryBoardName = "VirtualKeyboardSlideStoryBoard";
+        private const string VirtualKeyboardAnimationName = "VirtualKeyboardAnimation";
+        private const string BlackStripeTransformName = "BlackStripeTransform";
+
+        private Panel _layoutRoot;
+        private Border _contentBorder;
+        private TextBox _inputTextBox;
+        private PasswordBox _inputPasswordBox;
+        private TextBlock _titleTextBlock;
+        private TextBlock _textTextBlock;
+        private Panel _buttonsPanel;
+
+        private bool _usePasswordMode;
+        private bool _shown;
+        private TaskCompletionSource<string> _dismissTaskSource;
+        private List<ButtonBase> _buttons;
+
+        private Popup _dialogPopup;
+        private Panel _parentPanel;
+        private Panel _temporaryParentPanel;
+        private ContentControl _parentContentControl;
+
+        private TranslateTransform _blackStripeTransform;
+
+        private Storyboard _virtualKeyboardSlideStoryboard;
+
+        private DoubleAnimation _virtualKeyboardSlideAnimation;
+
+        public static readonly DependencyProperty ButtonStyleProperty =
+            DependencyProperty.Register(
+                "ButtonStyle",
+                typeof(Style),
+                typeof(InputDialog),
+                new PropertyMetadata(null));
+
+        public Style ButtonStyle
+        {
+            get { return (Style)GetValue(ButtonStyleProperty); }
+            set { SetValue(ButtonStyleProperty, value); }
+        }
+
+        public static readonly DependencyProperty InputTextProperty =
+            DependencyProperty.Register(
+                "InputText",
+                typeof(string),
+                typeof(InputDialog),
+                new PropertyMetadata("", OnInputTextChanged));
+
+        private string InputText
+        {
+            get { return (string)GetValue(InputTextProperty); }
+            set { SetValue(InputTextProperty, value); }
+        }
+
+        private static void OnInputTextChanged(
+            DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var target = (InputDialog)d;
+            var newInputText = target.InputText;
+            target.OnInputTextChanged(newInputText);
+        }
+
+        private void OnInputTextChanged(string newInputText)
+        {
+            if (_inputTextBox != null)
+            {
+                _inputTextBox.Text = newInputText;
+            }
+            if (_inputPasswordBox != null)
+            {
+                _inputPasswordBox.Password = newInputText;
+            }
+        }
+
+        public static readonly DependencyProperty BackgroundScreenBrushProperty =
+            DependencyProperty.Register(
+                "BackgroundScreenBrush",
+                typeof(Brush),
+                typeof(InputDialog),
+                new PropertyMetadata(null));
+
+        public Brush BackgroundScreenBrush
+        {
+            get { return (Brush)GetValue(BackgroundScreenBrushProperty); }
+            set { SetValue(BackgroundScreenBrushProperty, value); }
+        }
+
+        public static readonly DependencyProperty BackgroundStripeBrushProperty =
+            DependencyProperty.Register(
+                "BackgroundStripeBrush",
+                typeof(Brush),
+                typeof(InputDialog),
+                new PropertyMetadata(null));
+
+        public Brush BackgroundStripeBrush
+        {
+            get { return (Brush)GetValue(BackgroundStripeBrushProperty); }
+            set { SetValue(BackgroundStripeBrushProperty, value); }
+        }
+
+        public static readonly DependencyProperty TitleStyleProperty =
+            DependencyProperty.Register(
+                "TitleStyle",
+                typeof(Style),
+                typeof(InputDialog),
+                new PropertyMetadata(null));
+
+        public Style TitleStyle
+        {
+            get { return (Style)GetValue(TitleStyleProperty); }
+            set { SetValue(TitleStyleProperty, value); }
+        }
+
+        public static readonly DependencyProperty TextStyleProperty =
+            DependencyProperty.Register(
+                "TextStyle",
+                typeof(Style),
+                typeof(InputDialog),
+                new PropertyMetadata(null, OnTextStyleChanged));
+
+        public Style TextStyle
+        {
+            get { return (Style)GetValue(TextStyleProperty); }
+            set { SetValue(TextStyleProperty, value); }
+        }
+
+        private static void OnTextStyleChanged(
+            DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            var target = (InputDialog)d;
+            var oldTextStyle = (Style)e.OldValue;
+            var newTextStyle = target.TextStyle;
+            target.OnTextStyleChanged(oldTextStyle, newTextStyle);
+        }
+
+        private void OnTextStyleChanged(
+            Style oldTextStyle, Style newTextStyle)
+        {
+        }
+
+        public static readonly DependencyProperty InputTextStyleProperty =
+            DependencyProperty.Register(
+                "InputTextStyle",
+                typeof(Style),
+                typeof(InputDialog),
+                new PropertyMetadata(null));
+
+        public Style InputTextStyle
+        {
+            get { return (Style)GetValue(InputTextStyleProperty); }
+            set { SetValue(InputTextStyleProperty, value); }
+        }
+
+        public static readonly DependencyProperty InputPasswordStyleProperty =
+            DependencyProperty.Register(
+                "InputPasswordStyle",
+                typeof(Style),
+                typeof(InputDialog),
+                new PropertyMetadata(null));
+
+        public Style InputPasswordStyle
+        {
+            get { return (Style)GetValue(InputPasswordStyleProperty); }
+            set { SetValue(InputPasswordStyleProperty, value); }
+        }
+
+        public static readonly DependencyProperty IsLightDismissEnabledProperty =
+            DependencyProperty.Register(
+                "IsLightDismissEnabled",
+                typeof(bool),
+                typeof(InputDialog),
+                new PropertyMetadata(false));
+
+        public bool IsLightDismissEnabled
+        {
+            get { return (bool)GetValue(IsLightDismissEnabledProperty); }
+            set { SetValue(IsLightDismissEnabledProperty, value); }
+        }
+
+        public static readonly DependencyProperty AwaitsCloseTransitionProperty =
+            DependencyProperty.Register(
+                "AwaitsCloseTransition",
+                typeof(bool),
+                typeof(InputDialog),
+                new PropertyMetadata(true));
+
+        public bool AwaitsCloseTransition
+        {
+            get { return (bool)GetValue(AwaitsCloseTransitionProperty); }
+            set { SetValue(AwaitsCloseTransitionProperty, value); }
+        }
+
+        public static readonly DependencyProperty ButtonsPanelOrientationProperty =
+            DependencyProperty.Register(
+                "ButtonsPanelOrientation",
+                typeof(Orientation),
+                typeof(InputDialog),
+                new PropertyMetadata(Orientation.Horizontal));
+
+        public Orientation ButtonsPanelOrientation
+        {
+            get { return (Orientation)GetValue(ButtonsPanelOrientationProperty); }
+            set { SetValue(ButtonsPanelOrientationProperty, value); }
+        }
+
+        public InputDialog()
+        {
+            DefaultStyleKey = typeof(InputDialog);
+
+            Visibility = Visibility.Collapsed;
+        }
+
+        protected override void OnApplyTemplate()
+        {
+            base.OnApplyTemplate();
+            _layoutRoot = GetTemplateChild(LayoutRootPanelName) as Panel;
+            _contentBorder = GetTemplateChild(ContentBorderName) as Border;
+
+            _inputTextBox = GetTemplateChild(InputTextBoxName) as TextBox;
+            _inputPasswordBox = GetTemplateChild(InputPasswordBoxName) as PasswordBox;
+            _titleTextBlock = GetTemplateChild(TitleTextBlockName) as TextBlock;
+            _textTextBlock = GetTemplateChild(TextTextBlockName) as TextBlock;
+            _buttonsPanel = GetTemplateChild(ButtonsPanelName) as Panel;
+
+            _virtualKeyboardSlideStoryboard = GetTemplateChild(VirtualKeyboardSlideStoryBoardName) as Storyboard;
+            _virtualKeyboardSlideAnimation = GetTemplateChild(VirtualKeyboardAnimationName) as DoubleAnimation;
+            _blackStripeTransform = this.GetTemplateChild(BlackStripeTransformName) as TranslateTransform;
+
+            if (_layoutRoot != null)
+                _layoutRoot.Tapped += OnLayoutRootTapped;
+            if (_inputTextBox != null && _inputPasswordBox != null)
+            {
+                _inputTextBox.Text = InputText;
+                _inputTextBox.IsTextPredictionEnabled = false;
+                _inputTextBox.TextChanged += OnInputTextBoxTextChanged;
+                _inputTextBox.KeyUp += OnInputTextBoxKeyUp;
+
+                _inputPasswordBox.Password = InputText;
+                _inputPasswordBox.PasswordChanged += OnInputPasswordBoxTextChanged;
+                _inputPasswordBox.KeyUp += OnInputTextBoxKeyUp;
+
+                if (_usePasswordMode)
+                {
+                    _inputTextBox.Visibility = Visibility.Collapsed;
+                    _inputTextBox = null;
+                    _inputPasswordBox.Visibility = Visibility.Visible;
+                }
+                else
+                {
+                    _inputTextBox.Visibility = Visibility.Visible;
+                    _inputPasswordBox.Visibility = Visibility.Collapsed;
+                    _inputPasswordBox = null;
+                }
+            }
+            if (_contentBorder != null)
+                _contentBorder.Tapped += OnContentBorderTapped;
+        }
+
+        private void OnGlobalKeyUp(object sender, KeyRoutedEventArgs e)
+        {
+            if (e.Key == VirtualKey.Escape)
+            {
+                DismissDialog();
+                e.Handled = true;
+            }
+        }
+
+        private void OnLayoutRootTapped(object sender, TappedRoutedEventArgs e)
+        {
+            _buttons[0].Focus(FocusState.Programmatic); // Hide input panel
+
+            if (e.OriginalSource == sender &&
+                IsLightDismissEnabled)
+            {
+                _dismissTaskSource.TrySetResult(null);
+                e.Handled = true;
+            }
+        }
+
+        private void OnContentBorderTapped(object sender, TappedRoutedEventArgs e)
+        {
+            if (e.OriginalSource == sender)
+            {
+                _buttons[0].Focus(FocusState.Programmatic);
+                e.Handled = true;
+            }
+        }
+
+        private void OnInputTextBoxTextChanged(object sender, TextChangedEventArgs e)
+        {
+            InputText = _inputTextBox.Text;
+        }
+
+        private void OnInputPasswordBoxTextChanged(object sender, RoutedEventArgs e)
+        {
+            InputText = _inputPasswordBox.Password;
+        }
+
+        public async Task<string> ShowAsync(string title, string text, string defaultText, bool usePasswordMode)
+        {
+            _usePasswordMode = usePasswordMode;
+            if (_shown)
+            {
+                throw new InvalidOperationException("The dialog is already shown.");
+            }
+
+            Visibility = Visibility.Visible;
+            _shown = true;
+
+            Window.Current.Content.KeyUp += OnGlobalKeyUp;
+            _dismissTaskSource = new TaskCompletionSource<string>();
+
+            _parentPanel = Parent as Panel;
+            _parentContentControl = Parent as ContentControl;
+
+            if (_parentPanel != null)
+            {
+                _parentPanel.Children.Remove(this);
+            }
+
+            if (_parentContentControl != null)
+            {
+                _parentContentControl.Content = null;
+            }
+
+            _dialogPopup = new Popup { Child = this };
+
+            if (_parentPanel != null)
+            {
+                _parentPanel.Children.Add(_dialogPopup);
+                _parentPanel.SizeChanged += OnParentSizeChanged;
+            }
+            else if (_parentContentControl != null)
+            {
+                _parentContentControl.Content = _dialogPopup;
+                _parentContentControl.SizeChanged += OnParentSizeChanged;
+            }
+            else
+            {
+                _temporaryParentPanel = GetDescendants(Window.Current.Content).OfType<Panel>().FirstOrDefault();
+
+                if (_temporaryParentPanel != null)
+                {
+                    _temporaryParentPanel.Children.Add(_dialogPopup);
+                    _temporaryParentPanel.SizeChanged += OnParentSizeChanged;
+                }
+            }
+
+            _dialogPopup.IsOpen = true;
+
+            await WaitForLayoutUpdateAsync(this);
+
+            _titleTextBlock.Text = title;
+            _textTextBlock.Text = text;
+            InputText = defaultText;
+
+            _buttons = new List<ButtonBase>();
+
+            // Button OK
+            var btnOK = new Button();
+            if (ButtonStyle != null)
+                btnOK.Style = ButtonStyle;
+            btnOK.Content = "OK";
+            btnOK.Tag = 0;
+            btnOK.Click += OnButtonClick;
+            btnOK.KeyUp += OnGlobalKeyUp;
+            _buttons.Add(btnOK);
+            _buttonsPanel.Children.Add(btnOK);
+
+            // Button Cancel
+            var btnCancel = new Button();
+            if (ButtonStyle != null)
+                btnCancel.Style = ButtonStyle;
+            btnCancel.Content = "Cancel";
+            btnCancel.Tag = 1;
+            btnCancel.Click += OnButtonClick;
+            btnCancel.KeyUp += OnGlobalKeyUp;
+            _buttons.Add(btnCancel);
+            _buttonsPanel.Children.Add(btnCancel);
+
+            InputPane.GetForCurrentView().Showing += InputDialog_Showing;
+            InputPane.GetForCurrentView().Hiding += InputDialod_Hiding;
+
+            if (_inputTextBox != null)
+                _inputTextBox.Focus(FocusState.Programmatic);
+            if (_inputPasswordBox != null)
+                _inputPasswordBox.Focus(FocusState.Programmatic);
+
+            ResizeLayoutRoot();
+
+            // Show dialog
+            await GoToVisualStateAsync(this, _layoutRoot, PopupStatesGroupName, OpenPopupStateName);
+
+            // Wait for button click
+            var result = await _dismissTaskSource.Task;
+
+            // Hide dialog
+            if (AwaitsCloseTransition)
+            {
+                await CloseAsync();
+            }
+            else
+            {
+#pragma warning disable 4014
+                CloseAsync();
+#pragma warning restore 4014
+            }
+
+            InputPane.GetForCurrentView().Showing -= InputDialog_Showing;
+            InputPane.GetForCurrentView().Hiding -= InputDialod_Hiding;
+
+            Window.Current.Content.KeyUp -= OnGlobalKeyUp;
+
+            return result;
+        }
+
+        private void InputDialod_Hiding(InputPane sender, InputPaneVisibilityEventArgs args)
+        {
+            TranslateStripeTo(0);
+        }
+
+        void InputDialog_Showing(Windows.UI.ViewManagement.InputPane sender, Windows.UI.ViewManagement.InputPaneVisibilityEventArgs args)
+        {
+            TranslateStripeTo(args.OccludedRect.Height / -2);
+        }
+
+        private void TranslateStripeTo(double value)
+        {
+            if (_virtualKeyboardSlideAnimation == null || _virtualKeyboardSlideStoryboard == null)
+                return;
+
+            _blackStripeTransform.Y = value;
+            //_virtualKeyboardSlideAnimation.To = value;
+            //_virtualKeyboardSlideStoryboard.Begin();
+        }
+
+        static async Task WaitForLayoutUpdateAsync(FrameworkElement frameworkElement)
+        {
+            var tcs = new TaskCompletionSource<bool>();
+            EventHandler<object> eventHandler = (sender, args) => tcs.SetResult(true);
+            frameworkElement.LayoutUpdated += eventHandler;
+            await tcs.Task;
+            frameworkElement.LayoutUpdated -= eventHandler;
+        }
+
+        static IEnumerable<DependencyObject> GetDescendants(DependencyObject start)
+        {
+            var queue = new Queue<DependencyObject>();
+
+            var popup = start as Popup;
+
+            if (popup != null)
+            {
+                if (popup.Child != null)
+                {
+                    queue.Enqueue(popup.Child);
+                    yield return popup.Child;
+                }
+            }
+            else
+            {
+                var count = VisualTreeHelper.GetChildrenCount(start);
+
+                for (var i = 0; i < count; i++)
+                {
+                    var child = VisualTreeHelper.GetChild(start, i);
+                    queue.Enqueue(child);
+                    yield return child;
+                }
+            }
+
+            while (queue.Count > 0)
+            {
+                var parent = queue.Dequeue();
+
+                popup = parent as Popup;
+
+                if (popup != null)
+                {
+                    if (popup.Child != null)
+                    {
+                        queue.Enqueue(popup.Child);
+                        yield return popup.Child;
+                    }
+                }
+                else
+                {
+                    var count = VisualTreeHelper.GetChildrenCount(parent);
+
+                    for (var i = 0; i < count; i++)
+                    {
+                        var child = VisualTreeHelper.GetChild(parent, i);
+                        yield return child;
+                        queue.Enqueue(child);
+                    }
+                }
+            }
+        }
+
+        private void ResizeLayoutRoot()
+        {
+            var root =
+                _parentPanel ??
+                _parentContentControl ??
+                _temporaryParentPanel as FrameworkElement;
+            _layoutRoot.Width = root.ActualWidth;
+            _layoutRoot.Height = root.ActualHeight;
+        }
+
+        private void OnParentSizeChanged(object sender, SizeChangedEventArgs sizeChangedEventArgs)
+        {
+            ResizeLayoutRoot();
+        }
+
+        public async Task CloseAsync()
+        {
+            if (!_shown)
+            {
+                throw new InvalidOperationException("The dialog isn't shown, so it can't be closed.");
+            }
+
+            await GoToVisualStateAsync(this, _layoutRoot, PopupStatesGroupName, ClosedPopupStateName);
+            _dialogPopup.IsOpen = false;
+            _buttonsPanel.Children.Clear();
+
+            foreach (var button in _buttons)
+            {
+                button.Click -= OnButtonClick;
+                button.KeyUp -= OnGlobalKeyUp;
+            }
+
+            _buttons.Clear();
+
+            _dialogPopup.Child = null;
+
+            if (_parentPanel != null)
+            {
+                _parentPanel.Children.Remove(_dialogPopup);
+                _parentPanel.Children.Add(this);
+                _parentPanel.SizeChanged -= OnParentSizeChanged;
+                _parentPanel = null;
+            }
+
+            if (_parentContentControl != null)
+            {
+                _parentContentControl.Content = this;
+                _parentContentControl.SizeChanged -= OnParentSizeChanged;
+                _parentContentControl = null;
+            }
+
+            if (_temporaryParentPanel != null)
+            {
+                _temporaryParentPanel.Children.Remove(_dialogPopup);
+                _temporaryParentPanel.SizeChanged -= OnParentSizeChanged;
+                _temporaryParentPanel = null;
+            }
+
+            _dialogPopup = null;
+            Visibility = Visibility.Collapsed;
+            _shown = false;
+        }
+
+        private static async Task GoToVisualStateAsync(Control control,
+            FrameworkElement visualStatesHost,
+            string stateGroupName,
+            string stateName)
+        {
+            var tcs = new TaskCompletionSource<Storyboard>();
+
+            var storyboard =
+                GetStoryboardForVisualState(visualStatesHost, stateGroupName, stateName);
+
+            if (storyboard != null)
+            {
+                EventHandler<object> eh = null;
+
+                eh = (s, e) =>
+                {
+                    storyboard.Completed -= eh;
+                    tcs.SetResult(storyboard);
+                };
+
+                storyboard.Completed += eh;
+            }
+
+            VisualStateManager.GoToState(control, stateName, true);
+
+            if (storyboard == null)
+            {
+                return;
+            }
+
+            await tcs.Task;
+        }
+
+        private static Storyboard GetStoryboardForVisualState(
+            FrameworkElement visualStatesHost,
+            string stateGroupName,
+            string stateName)
+        {
+            Storyboard storyboard = null;
+
+            var stateGroups = VisualStateManager.GetVisualStateGroups(visualStatesHost);
+            VisualStateGroup stateGroup = null;
+
+            if (!string.IsNullOrEmpty(stateGroupName))
+            {
+                stateGroup = stateGroups.FirstOrDefault(g => g.Name == stateGroupName);
+            }
+
+            VisualState state = null;
+
+            if (stateGroup != null)
+            {
+                state = stateGroup.States.FirstOrDefault(s => s.Name == stateName);
+            }
+
+            if (state == null)
+            {
+                foreach (var group in stateGroups)
+                {
+                    state = group.States.FirstOrDefault(s => s.Name == stateName);
+
+                    if (state != null)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            if (state != null)
+            {
+                storyboard = state.Storyboard;
+            }
+
+            return storyboard;
+        }
+
+        private void OnButtonClick(object sender, RoutedEventArgs e)
+        {
+            var clickedButton = (ButtonBase)sender;
+            _dismissTaskSource.TrySetResult((int)clickedButton.Tag == 0 ? (_inputTextBox != null ? _inputTextBox.Text : _inputPasswordBox.Password) : null);
+
+            if (_buttons.Count > 0)
+            {
+                var button = (Button)_buttons[0];
+                button.Focus(FocusState.Programmatic);
+            }
+        }
+
+        private void OnInputTextBoxKeyUp(object sender, KeyRoutedEventArgs e)
+        {
+            if (_inputTextBox != null)
+                InputText = _inputTextBox.Text;
+            if (_inputPasswordBox != null)
+                InputText = _inputPasswordBox.Password;
+
+            if (e.Key == VirtualKey.Enter)
+            {
+                OnButtonClick(_buttons[0], new RoutedEventArgs());
+                e.Handled = true;
+                return;
+            }
+
+            if (e.Key == VirtualKey.Escape)
+            {
+                OnButtonClick(_buttons[1], new RoutedEventArgs());
+                e.Handled = true;
+            }
+        }
+
+        private void DismissDialog()
+        {
+            _dismissTaskSource.TrySetResult(null);
+
+            if (_buttons.Count > 0)
+            {
+                var button = (Button)_buttons[0];
+                button.Focus(FocusState.Programmatic);
+            }
+        }
+    }
+    #endregion
+}
diff --git a/MonoGame.Framework/Input/KeyboardInput.Windows.cs b/MonoGame.Framework/Input/KeyboardInput.Windows.cs
new file mode 100644
index 00000000000..842e1215055
--- /dev/null
+++ b/MonoGame.Framework/Input/KeyboardInput.Windows.cs
@@ -0,0 +1,97 @@
+using System.Drawing;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class KeyboardInput
+    {
+        private static Form _dialog;
+        private static TaskCompletionSource<string> _tcs;
+        
+        private static Task<string> PlatformShow(string title, string description, string defaultText, bool usePasswordMode)
+        {
+            _tcs = new TaskCompletionSource<string>();
+
+            var parent = Application.OpenForms[0];
+
+            parent.Invoke(new MethodInvoker(() =>
+            {
+                var dialog = _dialog = new Form();
+                dialog.Text = title;
+                dialog.FormBorderStyle = FormBorderStyle.FixedDialog;
+                dialog.MinimizeBox = false;
+                dialog.MaximizeBox = false;
+                dialog.ControlBox = false;
+                dialog.StartPosition = FormStartPosition.CenterParent;
+
+                var desc = new Label();
+                desc.Text = description;
+                desc.Parent = dialog;
+                desc.Top = 25;
+                desc.TextAlign = ContentAlignment.MiddleCenter;
+                desc.AutoSize = true;
+                desc.Margin = new Padding(25, 0, 25, 0);
+                desc.Left = (desc.Parent.ClientSize.Width - desc.Width) / 2;
+
+                var input = new TextBox();
+                input.Text = defaultText;
+                input.Parent = dialog;
+                input.Top = desc.Bottom + 15;
+                input.UseSystemPasswordChar = usePasswordMode;
+                input.AutoSize = true;
+                input.Margin = new Padding(25, 0, 25, 0);
+                input.Left = 25;
+                input.Width = input.Parent.ClientSize.Width - 25;
+                input.TabIndex = 0;
+
+                var bgroup = new FlowLayoutPanel();
+                bgroup.FlowDirection = FlowDirection.LeftToRight;
+                bgroup.Parent = dialog;
+                bgroup.Top = input.Bottom + 15;
+                bgroup.AutoSize = true;
+                bgroup.Margin = new Padding(15);
+                bgroup.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+
+                var button = new Button();
+                button.Text = "&Ok";
+                button.DialogResult = DialogResult.OK;
+                button.Parent = bgroup;
+                button.TabIndex = 1;
+                dialog.AcceptButton = button;
+
+                button = new Button();
+                button.Text = "&Cancel";
+                button.DialogResult = DialogResult.Cancel;
+                button.Parent = bgroup;
+                button.TabIndex = 2;
+                dialog.CancelButton = button;
+
+                bgroup.Left = (bgroup.Parent.ClientSize.Width - bgroup.Width) / 2;
+                dialog.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+                dialog.AutoSize = true;
+
+                var result = dialog.ShowDialog(parent);
+                _dialog = null;
+
+                if (_tcs.Task.IsCompleted)
+                    return;
+
+                if (result == DialogResult.OK)
+                    _tcs.SetResult(input.Text);
+                else
+                    _tcs.SetResult(null);
+
+            }));
+
+            return _tcs.Task;
+        }
+
+        private static void PlatformCancel(string result)
+        {
+            if (_dialog != null)
+                _dialog.Close();
+            _tcs.SetResult(result);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/KeyboardInput.cs b/MonoGame.Framework/Input/KeyboardInput.cs
new file mode 100644
index 00000000000..080151ad719
--- /dev/null
+++ b/MonoGame.Framework/Input/KeyboardInput.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class KeyboardInput
+    {
+        public static bool IsVisible { get; private set; }
+
+        /// <summary>
+        /// Displays the keyboard input interface asynchronously.
+        /// </summary>
+        /// <param name="title">Title of the dialog box.</param>
+        /// <param name="description">Description of the dialog box.</param>
+        /// <param name="defaultText">Default text displayed in the input area.</param>
+        /// <param name="usePasswordMode">If password mode is enabled, the characters entered are not displayed.</param>
+        /// <returns>Text entered by the player. Null if back was used.</returns>
+        /// <exception cref="System.Exception">Thrown when the message box is already visible</exception>
+        /// <example>
+        /// <code>
+        /// var name = await KeyboardInput.Show("Name", "What's your name?", "Player");
+        /// </code>
+        /// </example>
+        public static async Task<string> Show(string title, string description, string defaultText = "", bool usePasswordMode = false)
+        {
+            if (IsVisible)
+                throw new Exception("The function cannot be completed at this time: the KeyboardInput UI is already active. Wait until KeyboardInput.IsVisible is false before issuing this call.");
+
+            IsVisible = true;
+
+            var result = await PlatformShow(title, description, defaultText, usePasswordMode);
+
+            IsVisible = false;
+
+            return result;
+        }
+
+        /// <summary>
+        /// Hides the keyboard input interface and returns the parameter as the result of <see cref="Show"/>
+        /// </summary>
+        /// <param name="result">Result to return</param>
+        /// <exception cref="System.Exception">Thrown when the keyboard input is not visible</exception>
+        /// <example>
+        /// <code>
+        /// var nameTask = KeyboardInput.Show("Name", "What's your name?", "Player");
+        /// KeyboardInput.Cancel("John Doe");
+        /// var name = await nameTask;
+        /// </code>
+        /// </example>
+        public static void Cancel(string result)
+        {
+            if (!IsVisible)
+                throw new Exception("The function cannot be completed at this time: the MessageBox UI is not active.");
+
+            PlatformCancel(result);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/KeyboardInput.iOS.cs b/MonoGame.Framework/Input/KeyboardInput.iOS.cs
new file mode 100644
index 00000000000..20f4a292d54
--- /dev/null
+++ b/MonoGame.Framework/Input/KeyboardInput.iOS.cs
@@ -0,0 +1,56 @@
+using System.Threading.Tasks;
+using UIKit;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class KeyboardInput
+    {
+        private static TaskCompletionSource<string> tcs;
+        private static UIAlertView alert;
+
+        private static Task<string> PlatformShow(string title, string description, string defaultText, bool usePasswordMode)
+        {
+            tcs = new TaskCompletionSource<string>();
+
+            UIApplication.SharedApplication.InvokeOnMainThread(delegate
+            {
+                alert = new UIAlertView();
+                alert.Title = title;
+                alert.Message = description;
+                alert.AlertViewStyle = usePasswordMode ? UIAlertViewStyle.SecureTextInput : UIAlertViewStyle.PlainTextInput;
+                alert.AddButton("Cancel");
+                alert.AddButton("Ok");
+                UITextField alertTextField = alert.GetTextField(0);
+                alertTextField.KeyboardType = UIKeyboardType.ASCIICapable;
+                alertTextField.AutocorrectionType = UITextAutocorrectionType.No;
+                alertTextField.AutocapitalizationType = UITextAutocapitalizationType.Sentences;
+                alertTextField.Text = defaultText;
+                alert.Dismissed += (sender, e) =>
+                {
+                    if (!tcs.Task.IsCompleted)
+                        tcs.SetResult(e.ButtonIndex == 0 ? null : alert.GetTextField(0).Text);
+                };
+
+                // UIAlertView's textfield does not show keyboard in iOS8
+                // http://stackoverflow.com/questions/25563108/uialertviews-textfield-does-not-show-keyboard-in-ios8
+                if (UIDevice.CurrentDevice.CheckSystemVersion(8, 0))
+                    alert.Presented += (sender, args) => alertTextField.SelectAll(alert);
+
+                alert.Show();
+            });
+
+            return tcs.Task;
+        }
+
+        private static void PlatformCancel(string result)
+        {
+            if (!tcs.Task.IsCompleted)
+                tcs.SetResult(result);
+
+            UIApplication.SharedApplication.InvokeOnMainThread(delegate
+            {
+                alert.DismissWithClickedButtonIndex(0, true);
+            });
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/KeyboardState.cs b/MonoGame.Framework/Input/KeyboardState.cs
new file mode 100644
index 00000000000..47ccd321d99
--- /dev/null
+++ b/MonoGame.Framework/Input/KeyboardState.cs
@@ -0,0 +1,303 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Holds the state of keystrokes by a keyboard.
+    /// </summary>
+	public struct KeyboardState
+    {
+        // Used for the common situation where GetPressedKeys will return an empty array
+        static Keys[] empty = new Keys[0];
+
+        #region Key Data
+
+        // Array of 256 bits:
+        uint keys0, keys1, keys2, keys3, keys4, keys5, keys6, keys7;
+
+        bool InternalGetKey(Keys key)
+        {
+            uint mask = (uint)1 << (((int)key) & 0x1f);
+
+            uint element;
+            switch (((int)key) >> 5)
+            {
+                case 0: element = keys0; break;
+                case 1: element = keys1; break;
+                case 2: element = keys2; break;
+                case 3: element = keys3; break;
+                case 4: element = keys4; break;
+                case 5: element = keys5; break;
+                case 6: element = keys6; break;
+                case 7: element = keys7; break;
+                default: element = 0; break;
+            }
+
+            return (element & mask) != 0;
+        }
+
+        internal void InternalSetKey(Keys key)
+        {
+            uint mask = (uint)1 << (((int)key) & 0x1f);
+            switch (((int)key) >> 5)
+            {
+                case 0: keys0 |= mask; break;
+                case 1: keys1 |= mask; break;
+                case 2: keys2 |= mask; break;
+                case 3: keys3 |= mask; break;
+                case 4: keys4 |= mask; break;
+                case 5: keys5 |= mask; break;
+                case 6: keys6 |= mask; break;
+                case 7: keys7 |= mask; break;
+            }
+        }
+
+        internal void InternalClearKey(Keys key)
+        {
+            uint mask = (uint)1 << (((int)key) & 0x1f);
+            switch (((int)key) >> 5)
+            {
+                case 0: keys0 &= ~mask; break;
+                case 1: keys1 &= ~mask; break;
+                case 2: keys2 &= ~mask; break;
+                case 3: keys3 &= ~mask; break;
+                case 4: keys4 &= ~mask; break;
+                case 5: keys5 &= ~mask; break;
+                case 6: keys6 &= ~mask; break;
+                case 7: keys7 &= ~mask; break;
+            }
+        }
+
+        internal void InternalClearAllKeys()
+        {
+            keys0 = 0;
+            keys1 = 0;
+            keys2 = 0;
+            keys3 = 0;
+            keys4 = 0;
+            keys5 = 0;
+            keys6 = 0;
+            keys7 = 0;
+        }
+
+        #endregion
+
+
+        #region XNA Interface
+
+        /// <summary>
+        /// Gets the current state of the Caps Lock key.
+        /// </summary>
+        public bool CapsLock { get; private set; }
+
+        /// <summary>
+        /// Gets the current state of the Num Lock key.
+        /// </summary>
+        public bool NumLock { get; private set; }
+
+        internal KeyboardState(List<Keys> keys, bool capsLock = false, bool numLock = false) : this()
+        {
+            CapsLock = capsLock;
+            NumLock = numLock;
+
+            keys0 = 0;
+            keys1 = 0;
+            keys2 = 0;
+            keys3 = 0;
+            keys4 = 0;
+            keys5 = 0;
+            keys6 = 0;
+            keys7 = 0;
+
+            if (keys != null)
+                foreach (Keys k in keys)
+                    InternalSetKey(k);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="KeyboardState"/> class.
+        /// </summary>
+        /// <param name="keys">List of keys to be flagged as pressed on initialization.</param>
+        /// <param name="capsLock">Caps Lock state.</param>
+        /// <param name="numLock">Num Lock state.</param>
+        public KeyboardState(Keys[] keys, bool capsLock = false, bool numLock = false) : this()
+        {
+            CapsLock = capsLock;
+            NumLock = numLock;
+
+            keys0 = 0;
+            keys1 = 0;
+            keys2 = 0;
+            keys3 = 0;
+            keys4 = 0;
+            keys5 = 0;
+            keys6 = 0;
+            keys7 = 0;
+
+            if (keys != null)
+                foreach (Keys k in keys)
+                    InternalSetKey(k);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="KeyboardState"/> class.
+        /// </summary>
+        /// <param name="keys">List of keys to be flagged as pressed on initialization.</param>
+        public KeyboardState(params Keys[] keys) : this()
+        {
+            CapsLock = false;
+            NumLock = false;
+
+            keys0 = 0;
+            keys1 = 0;
+            keys2 = 0;
+            keys3 = 0;
+            keys4 = 0;
+            keys5 = 0;
+            keys6 = 0;
+            keys7 = 0;
+
+            if (keys != null)
+                foreach (Keys k in keys)
+                    InternalSetKey(k);
+        }
+
+        /// <summary>
+        /// Returns the state of a specified key.
+        /// </summary>
+        /// <param name="key">The key to query.</param>
+        /// <returns>The state of the key.</returns>
+        public KeyState this[Keys key]
+        {
+            get { return InternalGetKey(key) ? KeyState.Down : KeyState.Up; }
+        }
+
+        /// <summary>
+        /// Gets whether given key is currently being pressed.
+        /// </summary>
+        /// <param name="key">The key to query.</param>
+        /// <returns>true if the key is pressed; false otherwise.</returns>
+        public bool IsKeyDown(Keys key)
+        {
+            return InternalGetKey(key);
+        }
+
+        /// <summary>
+        /// Gets whether given key is currently being not pressed.
+        /// </summary>
+        /// <param name="key">The key to query.</param>
+        /// <returns>true if the key is not pressed; false otherwise.</returns>
+        public bool IsKeyUp(Keys key)
+        {
+            return !InternalGetKey(key);
+        }
+
+        #endregion
+
+
+        #region GetPressedKeys()
+
+        private static uint CountBits(uint v)
+        {
+            // http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
+            v = v - ((v >> 1) & 0x55555555);                    // reuse input as temporary
+            v = (v & 0x33333333) + ((v >> 2) & 0x33333333);     // temp
+            return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24; // count
+        }
+
+        private static int AddKeysToArray(uint keys, int offset, Keys[] pressedKeys, int index)
+        {
+            for (int i = 0; i < 32; i++)
+            {
+                if ((keys & (1 << i)) != 0)
+                    pressedKeys[index++] = (Keys)(offset + i);
+            }
+            return index;
+        }
+
+        /// <summary>
+        /// Returns an array of values holding keys that are currently being pressed.
+        /// </summary>
+        /// <returns>The keys that are currently being pressed.</returns>
+        public Keys[] GetPressedKeys()
+        {
+            uint count = CountBits(keys0) + CountBits(keys1) + CountBits(keys2) + CountBits(keys3)
+                    + CountBits(keys4) + CountBits(keys5) + CountBits(keys6) + CountBits(keys7);
+            if (count == 0)
+                return empty;
+            Keys[] keys = new Keys[count];
+
+            int index = 0;
+            if (keys0 != 0) index = AddKeysToArray(keys0, 0 * 32, keys, index);
+            if (keys1 != 0) index = AddKeysToArray(keys1, 1 * 32, keys, index);
+            if (keys2 != 0) index = AddKeysToArray(keys2, 2 * 32, keys, index);
+            if (keys3 != 0) index = AddKeysToArray(keys3, 3 * 32, keys, index);
+            if (keys4 != 0) index = AddKeysToArray(keys4, 4 * 32, keys, index);
+            if (keys5 != 0) index = AddKeysToArray(keys5, 5 * 32, keys, index);
+            if (keys6 != 0) index = AddKeysToArray(keys6, 6 * 32, keys, index);
+            if (keys7 != 0) index = AddKeysToArray(keys7, 7 * 32, keys, index);
+
+            return keys;
+        }
+
+        #endregion
+
+
+        #region Objet and Equality
+
+        /// <summary>
+        /// Gets the hash code for <see cref="KeyboardState"/> instance.
+        /// </summary>
+        /// <returns>Hash code of the object.</returns>
+        public override int GetHashCode()
+        {
+            return (int)(keys0 ^ keys1 ^ keys2 ^ keys3 ^ keys4 ^ keys5 ^ keys6 ^ keys7);
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="KeyboardState"/> instances are equal.
+        /// </summary>
+        /// <param name="a"><see cref="KeyboardState"/> instance to the left of the equality operator.</param>
+        /// <param name="b"><see cref="KeyboardState"/> instance to the right of the equality operator.</param>
+        /// <returns>true if the instances are equal; false otherwise.</returns>
+        public static bool operator ==(KeyboardState a, KeyboardState b)
+        {
+            return a.keys0 == b.keys0
+                && a.keys1 == b.keys1
+                && a.keys2 == b.keys2
+                && a.keys3 == b.keys3
+                && a.keys4 == b.keys4
+                && a.keys5 == b.keys5
+                && a.keys6 == b.keys6
+                && a.keys7 == b.keys7;
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="KeyboardState"/> instances are not equal.
+        /// </summary>
+        /// <param name="a"><see cref="KeyboardState"/> instance to the left of the inequality operator.</param>
+        /// <param name="b"><see cref="KeyboardState"/> instance to the right of the inequality operator.</param>
+        /// <returns>true if the instances are different; false otherwise.</returns>
+        public static bool operator !=(KeyboardState a, KeyboardState b)
+        {
+            return !(a == b);
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified object.
+        /// </summary>
+        /// <param name="obj">The <see cref="KeyboardState"/> to compare.</param>
+        /// <returns>true if the provided <see cref="KeyboardState"/> instance is same with current; false otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            return obj is KeyboardState && this == (KeyboardState)obj;
+        }
+
+        #endregion
+
+    }
+}
diff --git a/MonoGame.Framework/Input/KeyboardUtil.SDL.cs b/MonoGame.Framework/Input/KeyboardUtil.SDL.cs
new file mode 100644
index 00000000000..3b2eb1f0e94
--- /dev/null
+++ b/MonoGame.Framework/Input/KeyboardUtil.SDL.cs
@@ -0,0 +1,165 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    internal static class KeyboardUtil
+    {
+        static Dictionary<int, Keys> _map;
+
+        static KeyboardUtil()
+        {
+            _map = new Dictionary<int, Keys>();
+            _map.Add(8, Keys.Back);
+            _map.Add(9, Keys.Tab);
+            _map.Add(13, Keys.Enter);
+            _map.Add(27, Keys.Escape);
+            _map.Add(32, Keys.Space);
+            _map.Add(39, Keys.OemQuotes);
+            _map.Add(43, Keys.Add);
+            _map.Add(44, Keys.OemComma);
+            _map.Add(45, Keys.OemMinus);
+            _map.Add(46, Keys.OemPeriod);
+            _map.Add(47, Keys.OemQuestion);
+            _map.Add(48, Keys.D0);
+            _map.Add(49, Keys.D1);
+            _map.Add(50, Keys.D2);
+            _map.Add(51, Keys.D3);
+            _map.Add(52, Keys.D4);
+            _map.Add(53, Keys.D5);
+            _map.Add(54, Keys.D6);
+            _map.Add(55, Keys.D7);
+            _map.Add(56, Keys.D8);
+            _map.Add(57, Keys.D9);
+            _map.Add(59, Keys.OemSemicolon);
+            _map.Add(60, Keys.OemBackslash);
+            _map.Add(61, Keys.OemPlus);
+            _map.Add(91, Keys.OemOpenBrackets);
+            _map.Add(92, Keys.OemPipe);
+            _map.Add(93, Keys.OemCloseBrackets);
+            _map.Add(96, Keys.OemTilde);
+            _map.Add(97, Keys.A);
+            _map.Add(98, Keys.B);
+            _map.Add(99, Keys.C);
+            _map.Add(100, Keys.D);
+            _map.Add(101, Keys.E);
+            _map.Add(102, Keys.F);
+            _map.Add(103, Keys.G);
+            _map.Add(104, Keys.H);
+            _map.Add(105, Keys.I);
+            _map.Add(106, Keys.J);
+            _map.Add(107, Keys.K);
+            _map.Add(108, Keys.L);
+            _map.Add(109, Keys.M);
+            _map.Add(110, Keys.N);
+            _map.Add(111, Keys.O);
+            _map.Add(112, Keys.P);
+            _map.Add(113, Keys.Q);
+            _map.Add(114, Keys.R);
+            _map.Add(115, Keys.S);
+            _map.Add(116, Keys.T);
+            _map.Add(117, Keys.U);
+            _map.Add(118, Keys.V);
+            _map.Add(119, Keys.W);
+            _map.Add(120, Keys.X);
+            _map.Add(121, Keys.Y);
+            _map.Add(122, Keys.Z);
+            _map.Add(127, Keys.Delete);
+            _map.Add(1073741881, Keys.CapsLock);
+            _map.Add(1073741882, Keys.F1);
+            _map.Add(1073741883, Keys.F2);
+            _map.Add(1073741884, Keys.F3);
+            _map.Add(1073741885, Keys.F4);
+            _map.Add(1073741886, Keys.F5);
+            _map.Add(1073741887, Keys.F6);
+            _map.Add(1073741888, Keys.F7);
+            _map.Add(1073741889, Keys.F8);
+            _map.Add(1073741890, Keys.F9);
+            _map.Add(1073741891, Keys.F10);
+            _map.Add(1073741892, Keys.F11);
+            _map.Add(1073741893, Keys.F12);
+            _map.Add(1073741894, Keys.PrintScreen);
+            _map.Add(1073741895, Keys.Scroll);
+            _map.Add(1073741896, Keys.Pause);
+            _map.Add(1073741897, Keys.Insert);
+            _map.Add(1073741898, Keys.Home);
+            _map.Add(1073741899, Keys.PageUp);
+            _map.Add(1073741901, Keys.End);
+            _map.Add(1073741902, Keys.PageDown);
+            _map.Add(1073741903, Keys.Right);
+            _map.Add(1073741904, Keys.Left);
+            _map.Add(1073741905, Keys.Down);
+            _map.Add(1073741906, Keys.Up);
+            _map.Add(1073741907, Keys.NumLock);
+            _map.Add(1073741908, Keys.Divide);
+            _map.Add(1073741909, Keys.Multiply);
+            _map.Add(1073741910, Keys.Subtract);
+            _map.Add(1073741911, Keys.Add);
+            _map.Add(1073741912, Keys.Enter);
+            _map.Add(1073741913, Keys.NumPad1);
+            _map.Add(1073741914, Keys.NumPad2);
+            _map.Add(1073741915, Keys.NumPad3);
+            _map.Add(1073741916, Keys.NumPad4);
+            _map.Add(1073741917, Keys.NumPad5);
+            _map.Add(1073741918, Keys.NumPad6);
+            _map.Add(1073741919, Keys.NumPad7);
+            _map.Add(1073741920, Keys.NumPad8);
+            _map.Add(1073741921, Keys.NumPad9);
+            _map.Add(1073741922, Keys.NumPad0);
+            _map.Add(1073741923, Keys.Decimal);
+            _map.Add(1073741925, Keys.Apps);
+            _map.Add(1073741928, Keys.F13);
+            _map.Add(1073741929, Keys.F14);
+            _map.Add(1073741930, Keys.F15);
+            _map.Add(1073741931, Keys.F16);
+            _map.Add(1073741932, Keys.F17);
+            _map.Add(1073741933, Keys.F18);
+            _map.Add(1073741934, Keys.F19);
+            _map.Add(1073741935, Keys.F20);
+            _map.Add(1073741936, Keys.F21);
+            _map.Add(1073741937, Keys.F22);
+            _map.Add(1073741938, Keys.F23);
+            _map.Add(1073741939, Keys.F24);
+            _map.Add(1073741951, Keys.VolumeMute);
+            _map.Add(1073741952, Keys.VolumeUp);
+            _map.Add(1073741953, Keys.VolumeDown);
+            _map.Add(1073742040, Keys.OemClear);
+            _map.Add(1073742044, Keys.Decimal);
+            _map.Add(1073742048, Keys.LeftControl);
+            _map.Add(1073742049, Keys.LeftShift);
+            _map.Add(1073742050, Keys.LeftAlt);
+            _map.Add(1073742051, Keys.LeftWindows);
+            _map.Add(1073742052, Keys.RightControl);
+            _map.Add(1073742053, Keys.RightShift);
+            _map.Add(1073742054, Keys.RightAlt);
+            _map.Add(1073742055, Keys.RightWindows);
+            _map.Add(1073742082, Keys.MediaNextTrack);
+            _map.Add(1073742083, Keys.MediaPreviousTrack);
+            _map.Add(1073742084, Keys.MediaStop);
+            _map.Add(1073742085, Keys.MediaPlayPause);
+            _map.Add(1073742086, Keys.VolumeMute);
+            _map.Add(1073742087, Keys.SelectMedia);
+            _map.Add(1073742089, Keys.LaunchMail);
+            _map.Add(1073742092, Keys.BrowserSearch);
+            _map.Add(1073742093, Keys.BrowserHome);
+            _map.Add(1073742094, Keys.BrowserBack);
+            _map.Add(1073742095, Keys.BrowserForward);
+            _map.Add(1073742096, Keys.BrowserStop);
+            _map.Add(1073742097, Keys.BrowserRefresh);
+            _map.Add(1073742098, Keys.BrowserFavorites);
+            _map.Add(1073742106, Keys.Sleep);
+        }
+
+        public static Keys ToXna(int key)
+        {
+            if (_map.ContainsKey(key))
+                return _map[key];
+
+            return Keys.None;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Input/KeyboardUtil.Web.cs b/MonoGame.Framework/Input/KeyboardUtil.Web.cs
new file mode 100644
index 00000000000..94cb82d3076
--- /dev/null
+++ b/MonoGame.Framework/Input/KeyboardUtil.Web.cs
@@ -0,0 +1,209 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static class KeyboardUtil
+    {
+        public static Keys ToXna (int key, int location)
+        {
+            switch (key)
+            {
+                case 8:
+                    return Keys.Back;
+                case 9:
+                    return Keys.Tab;
+                case 13:
+                    return Keys.Enter;
+                case 16:
+                    return location == 1 ? Keys.LeftShift : Keys.RightShift;
+                case 17:
+                    return location == 1 ? Keys.LeftControl : Keys.RightControl;
+                case 18:
+                    return location == 1 ? Keys.LeftAlt : Keys.RightAlt;
+                case 19:
+                    return Keys.Pause;
+                case 20:
+                    return Keys.CapsLock;
+                case 27:
+                    return Keys.Escape;
+                case 32:
+                    return Keys.Space;
+                case 33:
+                    return Keys.PageUp;
+                case 34:
+                    return Keys.PageDown;
+                case 35:
+                    return Keys.End;
+                case 36:
+                    return Keys.Home;
+                case 37:
+                    return Keys.Left;
+                case 38:
+                    return Keys.Up;
+                case 39:
+                    return Keys.Right;
+                case 40:
+                    return Keys.Down;
+                case 45:
+                    return Keys.Insert;
+                case 46:
+                    return Keys.Delete;
+                case 48:
+                    return Keys.D0;
+                case 49:
+                    return Keys.D1;
+                case 50:
+                    return Keys.D2;
+                case 51:
+                    return Keys.D3;
+                case 52:
+                    return Keys.D4;
+                case 53:
+                    return Keys.D5;
+                case 54:
+                    return Keys.D6;
+                case 55:
+                    return Keys.D7;
+                case 56:
+                    return Keys.D8;
+                case 57:
+                    return Keys.D9;
+                case 65:
+                    return Keys.A;
+                case 66:
+                    return Keys.B;
+                case 67:
+                    return Keys.C;
+                case 68:
+                    return Keys.D;
+                case 69:
+                    return Keys.E;
+                case 70:
+                    return Keys.F;
+                case 71:
+                    return Keys.G;
+                case 72:
+                    return Keys.H;
+                case 73:
+                    return Keys.I;
+                case 74:
+                    return Keys.J;
+                case 75:
+                    return Keys.K;
+                case 76:
+                    return Keys.L;
+                case 77:
+                    return Keys.M;
+                case 78:
+                    return Keys.N;
+                case 79:
+                    return Keys.O;
+                case 80:
+                    return Keys.P;
+                case 81:
+                    return Keys.Q;
+                case 82:
+                    return Keys.R;
+                case 83:
+                    return Keys.S;
+                case 84:
+                    return Keys.T;
+                case 85:
+                    return Keys.U;
+                case 86:
+                    return Keys.V;
+                case 87:
+                    return Keys.W;
+                case 88:
+                    return Keys.X;
+                case 89:
+                    return Keys.Y;
+                case 90:
+                    return Keys.Z;
+                case 96:
+                    return Keys.NumPad0;
+                case 97:
+                    return Keys.NumPad1;
+                case 98:
+                    return Keys.NumPad2;
+                case 99:
+                    return Keys.NumPad3;
+                case 100:
+                    return Keys.NumPad4;
+                case 101:
+                    return Keys.NumPad5;
+                case 102:
+                    return Keys.NumPad6;
+                case 103:
+                    return Keys.NumPad7;
+                case 104:
+                    return Keys.NumPad8;
+                case 105:
+                    return Keys.NumPad9;
+                case 106:
+                    return Keys.Multiply;
+                case 107:
+                    return Keys.Add;
+                case 109:
+                    return Keys.Subtract;
+                case 110:
+                    return Keys.Decimal;
+                case 111:
+                    return Keys.Divide;
+                case 112:
+                    return Keys.F1;
+                case 113:
+                    return Keys.F2;
+                case 114:
+                    return Keys.F3;
+                case 115:
+                    return Keys.F4;
+                case 116:
+                    return Keys.F5;
+                case 117:
+                    return Keys.F6;
+                case 118:
+                    return Keys.F7;
+                case 119:
+                    return Keys.F8;
+                case 120:
+                    return Keys.F9;
+                case 121:
+                    return Keys.F10;
+                case 122:
+                    return Keys.F11;
+                case 123:
+                    return Keys.F12;
+                case 14:
+                    return Keys.NumLock;
+                case 145:
+                    return Keys.Scroll;
+                case 186:
+                    return Keys.OemSemicolon;
+                case 187:
+                    return Keys.OemPlus;
+                case 188:
+                    return Keys.OemComma;
+                case 189:
+                    return Keys.OemMinus;
+                case 190:
+                    return Keys.OemPeriod;
+                case 191:
+                    return Keys.OemQuestion;
+                case 192:
+                    return Keys.OemTilde;
+                case 219:
+                    return Keys.OemOpenBrackets;
+                case 220:
+                    return Keys.OemPipe;
+                case 221:
+                    return Keys.OemCloseBrackets;
+                case 222:
+                    return Keys.OemQuotes;
+            }
+
+            return Keys.None;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Input/Keys.cs b/MonoGame.Framework/Input/Keys.cs
new file mode 100644
index 00000000000..d91d1be309c
--- /dev/null
+++ b/MonoGame.Framework/Input/Keys.cs
@@ -0,0 +1,653 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Defines the keys on a keyboard.
+    /// </summary>	
+	public enum Keys
+	{
+        /// <summary>
+        /// Reserved.
+        /// </summary>
+		None = 0,
+        /// <summary>
+        /// BACKSPACE key.
+        /// </summary>
+		Back = 8,
+        /// <summary>
+        /// TAB key.
+        /// </summary>
+		Tab = 9,
+        /// <summary>
+        /// ENTER key.
+        /// </summary>
+		Enter = 13,
+        /// <summary>
+        /// CAPS LOCK key.
+        /// </summary>
+		CapsLock = 20,
+        /// <summary>
+        /// ESC key.
+        /// </summary>
+		Escape = 27,
+        /// <summary>
+        /// SPACEBAR key.
+        /// </summary>
+		Space = 32,
+        /// <summary>
+        /// PAGE UP key.
+        /// </summary>
+		PageUp = 33,
+        /// <summary>
+        /// PAGE DOWN key.
+        /// </summary>
+		PageDown = 34,
+        /// <summary>
+        /// END key.
+        /// </summary>
+		End = 35,
+        /// <summary>
+        /// HOME key.
+        /// </summary>
+		Home = 36,
+        /// <summary>
+        /// LEFT ARROW key.
+        /// </summary>
+		Left = 37,
+        /// <summary>
+        /// UP ARROW key.
+        /// </summary>
+		Up = 38,
+        /// <summary>
+        /// RIGHT ARROW key.
+        /// </summary>
+		Right = 39,
+        /// <summary>
+        /// DOWN ARROW key.
+        /// </summary>
+		Down = 40,
+        /// <summary>
+        /// SELECT key.
+        /// </summary>
+		Select = 41,
+        /// <summary>
+        /// PRINT key.
+        /// </summary>
+		Print = 42,
+        /// <summary>
+        /// EXECUTE key.
+        /// </summary>
+		Execute = 43,
+        /// <summary>
+        /// PRINT SCREEN key.
+        /// </summary>
+		PrintScreen = 44,
+        /// <summary>
+        /// INS key.
+        /// </summary>
+		Insert = 45,
+        /// <summary>
+        /// DEL key.
+        /// </summary>
+		Delete = 46,
+        /// <summary>
+        /// HELP key.
+        /// </summary>
+		Help = 47,
+        /// <summary>
+        /// Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+		D0 = 48,
+        /// <summary>
+        /// Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+		D1 = 49,
+        /// <summary>
+        /// Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+		D2 = 50,
+        /// <summary>
+        /// Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+		D3 = 51,
+        /// <summary>
+        /// Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+		D4 = 52,
+        /// <summary>
+        /// Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+		D5 = 53,
+        /// <summary>
+        /// Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+		D6 = 54,
+        /// <summary>
+        /// Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+		D7 = 55,
+        /// <summary>
+        /// Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+		D8 = 56,
+        /// <summary>
+        /// Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+		D9 = 57,
+        /// <summary>
+        /// A key.
+        /// </summary>
+		A = 65,
+        /// <summary>
+        /// B key.
+        /// </summary>
+		B = 66,
+        /// <summary>
+        /// C key.
+        /// </summary>
+		C = 67,
+        /// <summary>
+        /// D key.
+        /// </summary>
+		D = 68,
+        /// <summary>
+        /// E key.
+        /// </summary>
+		E = 69,
+        /// <summary>
+        /// F key.
+        /// </summary>
+		F = 70,
+        /// <summary>
+        /// G key.
+        /// </summary>
+		G = 71,
+        /// <summary>
+        /// H key.
+        /// </summary>
+		H = 72,
+        /// <summary>
+        /// I key.
+        /// </summary>
+		I = 73,
+        /// <summary>
+        /// J key.
+        /// </summary>
+		J = 74,
+        /// <summary>
+        /// K key.
+        /// </summary>
+		K = 75,
+        /// <summary>
+        /// L key.
+        /// </summary>
+		L = 76,
+        /// <summary>
+        /// M key.
+        /// </summary>
+		M = 77,
+        /// <summary>
+        /// N key.
+        /// </summary>
+		N = 78,
+        /// <summary>
+        /// O key.
+        /// </summary>
+		O = 79,
+        /// <summary>
+        /// P key.
+        /// </summary>
+		P = 80,
+        /// <summary>
+        /// Q key.
+        /// </summary>
+		Q = 81,
+        /// <summary>
+        /// R key.
+        /// </summary>
+		R = 82,
+        /// <summary>
+        /// S key.
+        /// </summary>
+		S = 83,
+        /// <summary>
+        /// T key.
+        /// </summary>
+		T = 84,
+        /// <summary>
+        /// U key.
+        /// </summary>
+		U = 85,
+        /// <summary>
+        /// V key.
+        /// </summary>
+		V = 86,
+        /// <summary>
+        /// W key.
+        /// </summary>
+		W = 87,
+        /// <summary>
+        /// X key.
+        /// </summary>
+		X = 88,
+        /// <summary>
+        /// Y key.
+        /// </summary>
+		Y = 89,
+        /// <summary>
+        /// Z key.
+        /// </summary>
+		Z = 90,
+        /// <summary>
+        /// Left Windows key.
+        /// </summary>
+		LeftWindows = 91,
+        /// <summary>
+        /// Right Windows key.
+        /// </summary>
+		RightWindows = 92,
+        /// <summary>
+        /// Applications key.
+        /// </summary>
+		Apps = 93,
+        /// <summary>
+        /// Computer Sleep key.
+        /// </summary>
+		Sleep = 95,
+        /// <summary>
+        /// Numeric keypad 0 key.
+        /// </summary>
+		NumPad0 = 96,
+        /// <summary>
+        /// Numeric keypad 1 key.
+        /// </summary>
+		NumPad1 = 97,
+        /// <summary>
+        /// Numeric keypad 2 key.
+        /// </summary>
+		NumPad2 = 98,
+        /// <summary>
+        /// Numeric keypad 3 key.
+        /// </summary>
+		NumPad3 = 99,
+        /// <summary>
+        /// Numeric keypad 4 key.
+        /// </summary>
+		NumPad4 = 100,
+        /// <summary>
+        /// Numeric keypad 5 key.
+        /// </summary>
+		NumPad5 = 101,
+        /// <summary>
+        /// Numeric keypad 6 key.
+        /// </summary>
+		NumPad6 = 102,
+        /// <summary>
+        /// Numeric keypad 7 key.
+        /// </summary>
+		NumPad7 = 103,
+        /// <summary>
+        /// Numeric keypad 8 key.
+        /// </summary>
+		NumPad8 = 104,
+        /// <summary>
+        /// Numeric keypad 9 key.
+        /// </summary>
+		NumPad9 = 105,
+        /// <summary>
+        /// Multiply key.
+        /// </summary>
+		Multiply = 106,
+        /// <summary>
+        /// Add key.
+        /// </summary>
+		Add = 107,
+        /// <summary>
+        /// Separator key.
+        /// </summary>
+		Separator = 108,
+        /// <summary>
+        /// Subtract key.
+        /// </summary>
+		Subtract = 109,
+        /// <summary>
+        /// Decimal key.
+        /// </summary>
+		Decimal = 110,
+        /// <summary>
+        /// Divide key.
+        /// </summary>
+		Divide = 111,
+        /// <summary>
+        /// F1 key.
+        /// </summary>
+		F1 = 112,
+        /// <summary>
+        /// F2 key.
+        /// </summary>
+		F2 = 113,
+        /// <summary>
+        /// F3 key.
+        /// </summary>
+		F3 = 114,
+        /// <summary>
+        /// F4 key.
+        /// </summary>
+		F4 = 115,
+        /// <summary>
+        /// F5 key.
+        /// </summary>
+		F5 = 116,
+        /// <summary>
+        /// F6 key.
+        /// </summary>
+		F6 = 117,
+        /// <summary>
+        /// F7 key.
+        /// </summary>
+		F7 = 118,
+        /// <summary>
+        /// F8 key.
+        /// </summary>
+		F8 = 119,
+        /// <summary>
+        /// F9 key.
+        /// </summary>
+		F9 = 120,
+        /// <summary>
+        /// F10 key.
+        /// </summary>
+		F10 = 121,
+        /// <summary>
+        /// F11 key.
+        /// </summary>
+		F11 = 122,
+        /// <summary>
+        /// F12 key.
+        /// </summary>
+		F12 = 123,
+        /// <summary>
+        /// F13 key.
+        /// </summary>
+		F13 = 124,
+        /// <summary>
+        /// F14 key.
+        /// </summary>
+		F14 = 125,
+        /// <summary>
+        /// F15 key.
+        /// </summary>
+		F15 = 126,
+        /// <summary>
+        /// F16 key.
+        /// </summary>
+		F16 = 127,
+        /// <summary>
+        /// F17 key.
+        /// </summary>
+		F17 = 128,
+        /// <summary>
+        /// F18 key.
+        /// </summary>
+		F18 = 129,
+        /// <summary>
+        /// F19 key.
+        /// </summary>
+		F19 = 130,
+        /// <summary>
+        /// F20 key.
+        /// </summary>
+		F20 = 131,
+        /// <summary>
+        /// F21 key.
+        /// </summary>
+		F21 = 132,
+        /// <summary>
+        /// F22 key.
+        /// </summary>
+		F22 = 133,
+        /// <summary>
+        /// F23 key.
+        /// </summary>
+		F23 = 134,
+        /// <summary>
+        /// F24 key.
+        /// </summary>
+		F24 = 135,
+        /// <summary>
+        /// NUM LOCK key.
+        /// </summary>
+		NumLock = 144,
+        /// <summary>
+        /// SCROLL LOCK key.
+        /// </summary>
+		Scroll = 145,
+        /// <summary>
+        /// Left SHIFT key.
+        /// </summary>
+		LeftShift = 160,
+        /// <summary>
+        /// Right SHIFT key.
+        /// </summary>
+		RightShift = 161,
+        /// <summary>
+        /// Left CONTROL key.
+        /// </summary>
+		LeftControl = 162,
+        /// <summary>
+        /// Right CONTROL key.
+        /// </summary>
+		RightControl = 163,
+        /// <summary>
+        /// Left ALT key.
+        /// </summary>
+		LeftAlt = 164,
+        /// <summary>
+        /// Right ALT key.
+        /// </summary>
+		RightAlt = 165,
+        /// <summary>
+        /// Browser Back key.
+        /// </summary>
+		BrowserBack = 166,
+        /// <summary>
+        /// Browser Forward key.
+        /// </summary>
+		BrowserForward = 167,
+        /// <summary>
+        /// Browser Refresh key.
+        /// </summary>
+		BrowserRefresh = 168,
+        /// <summary>
+        /// Browser Stop key.
+        /// </summary>
+		BrowserStop = 169,
+        /// <summary>
+        /// Browser Search key.
+        /// </summary>
+		BrowserSearch = 170,
+        /// <summary>
+        /// Browser Favorites key.
+        /// </summary>
+		BrowserFavorites = 171,
+        /// <summary>
+        /// Browser Start and Home key.
+        /// </summary>
+		BrowserHome = 172,
+		/// <summary>
+        /// Volume Mute key.
+		/// </summary>
+        VolumeMute = 173,
+        /// <summary>
+        /// Volume Down key.
+        /// </summary>
+		VolumeDown = 174,
+        /// <summary>
+        /// Volume Up key.
+        /// </summary>
+		VolumeUp = 175,
+        /// <summary>
+        /// Next Track key.
+        /// </summary>
+		MediaNextTrack = 176,
+        /// <summary>
+        /// Previous Track key.
+        /// </summary>
+		MediaPreviousTrack = 177,
+        /// <summary>
+        /// Stop Media key.
+        /// </summary>
+		MediaStop = 178,
+        /// <summary>
+        /// Play/Pause Media key.
+        /// </summary>
+		MediaPlayPause = 179,
+        /// <summary>
+        /// Start Mail key.
+        /// </summary>
+		LaunchMail = 180,
+        /// <summary>
+        /// Select Media key.
+        /// </summary>
+		SelectMedia = 181,
+        /// <summary>
+        /// Start Application 1 key.
+        /// </summary>
+		LaunchApplication1 = 182,
+        /// <summary>
+        /// Start Application 2 key.
+        /// </summary>
+		LaunchApplication2 = 183,
+        /// <summary>
+        /// The OEM Semicolon key on a US standard keyboard.
+        /// </summary>
+		OemSemicolon = 186,
+        /// <summary>
+        /// For any country/region, the '+' key.
+        /// </summary>
+		OemPlus = 187,
+        /// <summary>
+        /// For any country/region, the ',' key.
+        /// </summary>
+		OemComma = 188,
+        /// <summary>
+        /// For any country/region, the '-' key.
+        /// </summary>
+		OemMinus = 189,
+        /// <summary>
+        /// For any country/region, the '.' key.
+        /// </summary>
+		OemPeriod = 190,
+        /// <summary>
+        /// The OEM question mark key on a US standard keyboard.
+        /// </summary>
+		OemQuestion = 191,
+        /// <summary>
+        /// The OEM tilde key on a US standard keyboard.
+        /// </summary>
+		OemTilde = 192,
+        /// <summary>
+        /// The OEM open bracket key on a US standard keyboard.
+        /// </summary>
+		OemOpenBrackets = 219,
+        /// <summary>
+        /// The OEM pipe key on a US standard keyboard.
+        /// </summary>
+		OemPipe = 220,
+        /// <summary>
+        /// The OEM close bracket key on a US standard keyboard.
+        /// </summary>
+		OemCloseBrackets = 221,
+        /// <summary>
+        /// The OEM singled/double quote key on a US standard keyboard.
+        /// </summary>
+		OemQuotes = 222,
+        /// <summary>
+        /// Used for miscellaneous characters; it can vary by keyboard.
+        /// </summary>
+		Oem8 = 223,
+        /// <summary>
+        /// The OEM angle bracket or backslash key on the RT 102 key keyboard.
+        /// </summary>
+		OemBackslash = 226,
+        /// <summary>
+        /// IME PROCESS key.
+        /// </summary>
+		ProcessKey = 229,
+        /// <summary>
+        /// Attn key.
+        /// </summary>
+		Attn = 246,
+        /// <summary>
+        /// CrSel key.
+        /// </summary>
+		Crsel = 247,
+        /// <summary>
+        /// ExSel key.
+        /// </summary>
+		Exsel = 248,
+        /// <summary>
+        /// Erase EOF key.
+        /// </summary>
+		EraseEof = 249,
+        /// <summary>
+        /// Play key.
+        /// </summary>
+		Play = 250,
+        /// <summary>
+        /// Zoom key.
+        /// </summary>
+		Zoom = 251,
+        /// <summary>
+        /// PA1 key.
+        /// </summary>
+		Pa1 = 253,
+        /// <summary>
+        /// CLEAR key.
+        /// </summary>
+		OemClear = 254,
+        /// <summary>
+        /// Green ChatPad key.
+        /// </summary>
+		ChatPadGreen = 0xCA,
+        /// <summary>
+        /// Orange ChatPad key.
+        /// </summary>
+		ChatPadOrange = 0xCB,
+        /// <summary>
+        /// PAUSE key.
+        /// </summary>
+		Pause = 0x13,
+        /// <summary>
+        /// IME Convert key.
+        /// </summary>
+		ImeConvert = 0x1c,
+        /// <summary>
+        /// IME NoConvert key.
+        /// </summary>
+		ImeNoConvert = 0x1d,
+        /// <summary>
+        /// Kana key on Japanese keyboards.
+        /// </summary>
+		Kana = 0x15,
+        /// <summary>
+        /// Kanji key on Japanese keyboards.
+        /// </summary>
+		Kanji = 0x19,
+        /// <summary>
+        /// OEM Auto key.
+        /// </summary>
+		OemAuto = 0xf3,
+        /// <summary>
+        /// OEM Copy key.
+        /// </summary>
+		OemCopy = 0xf2,
+        /// <summary>
+        /// OEM Enlarge Window key.
+        /// </summary>
+		OemEnlW = 0xf4
+	}
+}
diff --git a/MonoGame.Framework/Input/MessageBox.Android.cs b/MonoGame.Framework/Input/MessageBox.Android.cs
new file mode 100644
index 00000000000..de307f062e5
--- /dev/null
+++ b/MonoGame.Framework/Input/MessageBox.Android.cs
@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Android.App;
+using Android.Content;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class MessageBox
+    {
+        private static TaskCompletionSource<int?> tcs;
+        private static AlertDialog alert;
+
+        private static Task<int?> PlatformShow(string title, string description, List<string> buttons)
+        {
+            tcs = new TaskCompletionSource<int?>();
+            Game.Activity.RunOnUiThread(() =>
+            {
+                alert = new AlertDialog.Builder(Game.Activity).Create();
+
+                alert.SetTitle(title);
+                alert.SetMessage(description);
+
+                alert.SetButton((int)DialogButtonType.Positive, buttons[0], (sender, args) =>
+                {
+                    if (!tcs.Task.IsCompleted)
+                        tcs.SetResult(0);
+                });
+
+                if (buttons.Count > 1)
+                {
+                    alert.SetButton((int)DialogButtonType.Negative, buttons[1], (sender, args) =>
+                    {
+                        if (!tcs.Task.IsCompleted)
+                            tcs.SetResult(1);
+                    });
+                }
+
+                if (buttons.Count > 2)
+                {
+                    alert.SetButton((int)DialogButtonType.Neutral, buttons[2], (sender, args) =>
+                    {
+                        if (!tcs.Task.IsCompleted)
+                            tcs.SetResult(2);
+                    });
+                }
+
+                alert.CancelEvent += (sender, args) =>
+                {
+                    if (!tcs.Task.IsCompleted)
+                        tcs.SetResult(null);
+                };
+
+                alert.Show();
+            });
+
+            return tcs.Task;
+        }
+
+        private static void PlatformCancel(int? result)
+        {
+            alert.Dismiss();
+            tcs.SetResult(result);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/MessageBox.WinRT.cs b/MonoGame.Framework/Input/MessageBox.WinRT.cs
new file mode 100644
index 00000000000..21e31f9ddd3
--- /dev/null
+++ b/MonoGame.Framework/Input/MessageBox.WinRT.cs
@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.Core;
+using Windows.Foundation;
+using Windows.UI.Core;
+using Windows.UI.Popups;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class MessageBox
+    {
+        private static readonly CoreDispatcher dispatcher;
+        private static TaskCompletionSource<int?> tcs;
+        private static IAsyncOperation<IUICommand> dialogResult; 
+
+        static MessageBox()
+        {
+            dispatcher = CoreApplication.MainView.CoreWindow.Dispatcher;
+        }
+
+        private static Task<int?> PlatformShow(string title, string description, List<string> buttons)
+        {
+            // TODO: MessageDialog only supports two buttons
+            if (buttons.Count == 3)
+                throw new NotSupportedException("This platform does not support three buttons");
+
+            tcs = new TaskCompletionSource<int?>();
+
+            MessageDialog dialog = new MessageDialog(description, title);
+            foreach (string button in buttons)
+                dialog.Commands.Add(new UICommand(button, null, dialog.Commands.Count));
+
+            dispatcher.RunAsync(CoreDispatcherPriority.Normal,
+                async () =>
+                {
+                    try
+                    {
+                        // PlatformSetResult will cancel the task, resulting in an exception
+                        dialogResult = dialog.ShowAsync();
+                        var result = await dialogResult;
+                        if (!tcs.Task.IsCompleted)
+                            tcs.SetResult(result == null ? null : (int?)result.Id);
+                    }
+                    catch (TaskCanceledException)
+                    {
+                        if (!tcs.Task.IsCompleted)
+                            tcs.SetResult(null);
+                    }
+                });
+
+            return tcs.Task;
+        }
+
+        private static void PlatformCancel(int? result)
+        {
+            // TODO: MessageDialog doesn't hide on Windows Phone 8.1
+            tcs.SetResult(result);
+            dialogResult.Cancel();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/MessageBox.Windows.cs b/MonoGame.Framework/Input/MessageBox.Windows.cs
new file mode 100644
index 00000000000..7d08fc60672
--- /dev/null
+++ b/MonoGame.Framework/Input/MessageBox.Windows.cs
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class MessageBox
+    {
+        private static Form _dialog;
+        private static TaskCompletionSource<int?> _tcs;
+
+        private static Task<int?> PlatformShow(string title, string description, List<string> buttons)
+        {
+            _tcs = new TaskCompletionSource<int?>();
+
+            var parent = Application.OpenForms[0];
+
+            parent.Invoke(new MethodInvoker(() =>
+            {
+                var dialog = _dialog = new Form();
+                dialog.Text = title;
+                dialog.FormBorderStyle = FormBorderStyle.FixedDialog;
+                dialog.MinimizeBox = false;
+                dialog.MaximizeBox = false;
+                dialog.ControlBox = false;
+                dialog.StartPosition = FormStartPosition.CenterParent;
+
+                var desc = new Label();
+                desc.Text = description;
+                desc.Parent = dialog;
+                desc.Top = 25;
+                desc.TextAlign = ContentAlignment.MiddleCenter;
+                desc.AutoSize = true;
+                desc.Margin = new Padding(25, 0, 25, 0);
+                desc.Left = (desc.Parent.ClientSize.Width - desc.Width) / 2;
+
+                var bgroup = new FlowLayoutPanel();
+                bgroup.FlowDirection = FlowDirection.LeftToRight;
+                bgroup.Parent = dialog;
+                bgroup.Top = desc.Bottom + 25;
+                bgroup.AutoSize = true;
+                bgroup.Margin = new Padding(15);
+                bgroup.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+
+                for (var i = 0; i < buttons.Count; i++)
+                {
+                    string btext = buttons[i];
+                    var button = new Button();
+                    button.Text = btext;
+                    button.DialogResult = (DialogResult)i+1;
+                    button.Parent = bgroup;
+                    if (i == 0)
+                        dialog.AcceptButton = button;
+                }
+
+                bgroup.Left = (bgroup.Parent.ClientSize.Width - bgroup.Width) / 2;
+                dialog.AutoSizeMode = AutoSizeMode.GrowAndShrink;
+                dialog.AutoSize = true;
+
+                var result = (int)dialog.ShowDialog(parent);
+                _dialog = null;
+
+                if (_tcs.Task.IsCompleted)
+                    return;
+
+                _tcs.SetResult(result-1);
+            }));
+
+            return _tcs.Task;
+        }
+
+        private static void PlatformCancel(int? result)
+        {
+            if (_dialog != null)
+                _dialog.Close();
+            _tcs.SetResult(result);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/MessageBox.cs b/MonoGame.Framework/Input/MessageBox.cs
new file mode 100644
index 00000000000..ab816ce6a4e
--- /dev/null
+++ b/MonoGame.Framework/Input/MessageBox.cs
@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class MessageBox
+    {
+        public static bool IsVisible { get; private set; }
+
+        /// <summary>
+        /// Displays the message box interface asynchronously.
+        /// </summary>
+        /// <param name="title">Title of the message box.</param>
+        /// <param name="description">Description of the message box.</param>
+        /// <param name="buttons">Captions of the message box buttons. Up to three supported.</param>
+        /// <returns>Index of button selected by the player. Null if back was used.</returns>
+        /// <exception cref="System.Exception">Thrown when the message box is already visible</exception>
+        /// <example>
+        /// <code>
+        /// var color = await MessageBox.Show("Color", "What's your favorite color?", new[] { "Red", "Green", "Blue" });
+        /// </code>
+        /// </example>
+        public static async Task<int?> Show(string title, string description, IEnumerable<string> buttons)
+        {
+            if (IsVisible)
+                throw new Exception("The function cannot be completed at this time: the MessageBox UI is already active. Wait until MessageBox.IsVisible is false before issuing this call.");
+
+            IsVisible = true;
+
+            var buttonsList = buttons.ToList();
+            if (buttonsList.Count > 3 || buttonsList.Count == 0)
+                throw new ArgumentException("Invalid number of buttons: one to three required", "buttons");
+
+            var result = await PlatformShow(title, description, buttonsList);
+
+            IsVisible = false;
+
+            return result;
+        }
+
+        /// <summary>
+        /// Hides the message box interface and returns the parameter as the result of <see cref="Show"/>
+        /// </summary>
+        /// <param name="result">Result to return</param>
+        /// <exception cref="System.Exception">Thrown when the message box is not visible</exception>
+        /// <example>
+        /// <code>
+        /// var colorTask = MessageBox.Show("Color", "What's your favorite color?", new[] { "Red", "Green", "Blue" });
+        /// MessageBox.Cancel(0);
+        /// var color = await colorTask;
+        /// </code>
+        /// </example>
+        public static void Cancel(int? result)
+        {
+            if (!IsVisible)
+                throw new Exception("The function cannot be completed at this time: the MessageBox UI is not active.");
+
+            PlatformCancel(result);
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Input/MessageBox.iOS.cs b/MonoGame.Framework/Input/MessageBox.iOS.cs
new file mode 100644
index 00000000000..827ff47aee5
--- /dev/null
+++ b/MonoGame.Framework/Input/MessageBox.iOS.cs
@@ -0,0 +1,44 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using UIKit;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class MessageBox
+    {
+        private static TaskCompletionSource<int?> tcs;
+        private static UIAlertView alert;
+
+        private static Task<int?> PlatformShow(string title, string description, List<string> buttons)
+        {
+            tcs = new TaskCompletionSource<int?>();
+            UIApplication.SharedApplication.InvokeOnMainThread(delegate
+            {
+                alert = new UIAlertView();
+                alert.Title = title;
+                alert.Message = description;
+                foreach (string button in buttons)
+                    alert.AddButton(button);
+                alert.Dismissed += (sender, e) =>
+                {
+                    if (!tcs.Task.IsCompleted)
+					    tcs.SetResult((int)e.ButtonIndex);
+                };
+                alert.Show();
+            });
+
+            return tcs.Task;
+        }
+
+        private static void PlatformCancel(int? result)
+        {
+            if (!tcs.Task.IsCompleted)
+                tcs.SetResult(result);
+
+            UIApplication.SharedApplication.InvokeOnMainThread(delegate
+            {
+                alert.DismissWithClickedButtonIndex(0, true);
+            });
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/Mouse.Default.cs b/MonoGame.Framework/Input/Mouse.Default.cs
new file mode 100644
index 00000000000..80f49d1b7d5
--- /dev/null
+++ b/MonoGame.Framework/Input/Mouse.Default.cs
@@ -0,0 +1,36 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class Mouse
+    {
+        private static IntPtr PlatformGetWindowHandle()
+        {
+            return IntPtr.Zero;
+        }
+
+        private static void PlatformSetWindowHandle(IntPtr windowHandle)
+        {
+        }
+
+        private static MouseState PlatformGetState(GameWindow window)
+        {
+            return window.MouseState;
+        }
+
+        private static void PlatformSetPosition(int x, int y)
+        {
+            PrimaryWindow.MouseState.X = x;
+            PrimaryWindow.MouseState.Y = y;
+        }
+
+        public static void PlatformSetCursor(MouseCursor cursor)
+        {
+
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/Mouse.SDL.cs b/MonoGame.Framework/Input/Mouse.SDL.cs
new file mode 100644
index 00000000000..f558a712031
--- /dev/null
+++ b/MonoGame.Framework/Input/Mouse.SDL.cs
@@ -0,0 +1,65 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class Mouse
+    {
+        internal static int ScrollX;
+        internal static int ScrollY;
+
+        private static IntPtr PlatformGetWindowHandle()
+        {
+            return PrimaryWindow.Handle;
+        }
+        
+        private static void PlatformSetWindowHandle(IntPtr windowHandle)
+        {
+        }
+
+        private static MouseState PlatformGetState(GameWindow window)
+        {
+            int x, y;
+            var winFlags = Sdl.Window.GetWindowFlags(window.Handle);
+            var state = Sdl.Mouse.GetGlobalState(out x, out y);
+
+            if ((winFlags & Sdl.Window.State.MouseFocus) != 0)
+            {
+                // Window has mouse focus, position will be set from the motion event
+                window.MouseState.LeftButton = (state & Sdl.Mouse.Button.Left) != 0 ? ButtonState.Pressed : ButtonState.Released;
+                window.MouseState.MiddleButton = (state & Sdl.Mouse.Button.Middle) != 0 ? ButtonState.Pressed : ButtonState.Released;
+                window.MouseState.RightButton = (state & Sdl.Mouse.Button.Right) != 0 ? ButtonState.Pressed : ButtonState.Released;
+                window.MouseState.XButton1 = (state & Sdl.Mouse.Button.X1Mask) != 0 ? ButtonState.Pressed : ButtonState.Released;
+                window.MouseState.XButton2 = (state & Sdl.Mouse.Button.X2Mask) != 0 ? ButtonState.Pressed : ButtonState.Released;
+
+                window.MouseState.HorizontalScrollWheelValue = ScrollX;
+                window.MouseState.ScrollWheelValue = ScrollY;
+            }
+            else
+            {
+                // Window does not have mouse focus, we need to manually get the position
+                var clientBounds = window.ClientBounds;
+                window.MouseState.X = x - clientBounds.X;
+                window.MouseState.Y = y - clientBounds.Y;
+            }
+
+            return window.MouseState;
+        }
+
+        private static void PlatformSetPosition(int x, int y)
+        {
+            PrimaryWindow.MouseState.X = x;
+            PrimaryWindow.MouseState.Y = y;
+            
+            Sdl.Mouse.WarpInWindow(PrimaryWindow.Handle, x, y);
+        }
+
+        private static void PlatformSetCursor(MouseCursor cursor)
+        {
+            Sdl.Mouse.SetCursor(cursor.Handle);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/Mouse.Windows.cs b/MonoGame.Framework/Input/Mouse.Windows.cs
new file mode 100644
index 00000000000..b230ccd30f9
--- /dev/null
+++ b/MonoGame.Framework/Input/Mouse.Windows.cs
@@ -0,0 +1,48 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public static partial class Mouse
+    {
+        [DllImportAttribute("user32.dll", EntryPoint = "SetCursorPos")]
+        [return: MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.Bool)]
+        private static extern bool SetCursorPos(int X, int Y);
+
+        private static Control _window;
+
+        private static IntPtr PlatformGetWindowHandle()
+        {
+            return _window.Handle;
+        }
+
+        private static void PlatformSetWindowHandle(IntPtr windowHandle)
+        {
+            _window = Control.FromHandle(windowHandle);
+        }
+
+        private static MouseState PlatformGetState(GameWindow window)
+        {
+            return window.MouseState;
+        }
+
+        private static void PlatformSetPosition(int x, int y)
+        {
+            PrimaryWindow.MouseState.X = x;
+            PrimaryWindow.MouseState.Y = y;
+            
+            var pt = _window.PointToScreen(new System.Drawing.Point(x, y));
+            SetCursorPos(pt.X, pt.Y);
+        }
+
+        public static void PlatformSetCursor(MouseCursor cursor)
+        {
+            _window.Cursor = cursor.Cursor;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/Mouse.cs b/MonoGame.Framework/Input/Mouse.cs
new file mode 100644
index 00000000000..79ec222fb90
--- /dev/null
+++ b/MonoGame.Framework/Input/Mouse.cs
@@ -0,0 +1,70 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Allows reading position and button click information from mouse.
+    /// </summary>
+    public static partial class Mouse
+    {
+        internal static GameWindow PrimaryWindow;
+
+        private static readonly MouseState _defaultState = new MouseState();
+
+        /// <summary>
+        /// Gets or sets the window handle for current mouse processing.
+        /// </summary> 
+        public static IntPtr WindowHandle
+        {
+            get { return PlatformGetWindowHandle(); }
+            set { PlatformSetWindowHandle(value); }
+        }
+
+        /// <summary>
+        /// This API is an extension to XNA.
+        /// Gets mouse state information that includes position and button
+        /// presses for the provided window
+        /// </summary>
+        /// <returns>Current state of the mouse.</returns>
+        public static MouseState GetState(GameWindow window)
+        {
+            return PlatformGetState(window);
+        }
+
+        /// <summary>
+        /// Gets mouse state information that includes position and button presses
+        /// for the primary window
+        /// </summary>
+        /// <returns>Current state of the mouse.</returns>
+        public static MouseState GetState()
+        {
+            if (PrimaryWindow != null)
+                return GetState(PrimaryWindow);
+
+            return _defaultState;
+        }
+
+        /// <summary>
+        /// Sets mouse cursor's relative position to game-window.
+        /// </summary>
+        /// <param name="x">Relative horizontal position of the cursor.</param>
+        /// <param name="y">Relative vertical position of the cursor.</param>
+        public static void SetPosition(int x, int y)
+        {
+            PlatformSetPosition(x, y);
+        }
+
+        /// <summary>
+        /// Sets the cursor image to the specified MouseCursor.
+        /// </summary>
+        /// <param name="cursor">Mouse cursor to use for the cursor image.</param>
+        public static void SetCursor(MouseCursor cursor)
+        {
+            PlatformSetCursor(cursor);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/MouseCursor.Default.cs b/MonoGame.Framework/Input/MouseCursor.Default.cs
new file mode 100644
index 00000000000..9e641d0cb97
--- /dev/null
+++ b/MonoGame.Framework/Input/MouseCursor.Default.cs
@@ -0,0 +1,37 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public partial class MouseCursor
+    {
+        private static void PlatformInitalize()
+        {
+            Arrow = new MouseCursor(IntPtr.Zero);
+            IBeam = new MouseCursor(IntPtr.Zero);
+            Wait = new MouseCursor(IntPtr.Zero);
+            Crosshair = new MouseCursor(IntPtr.Zero);
+            WaitArrow = new MouseCursor(IntPtr.Zero);
+            SizeNWSE = new MouseCursor(IntPtr.Zero);
+            SizeNESW = new MouseCursor(IntPtr.Zero);
+            SizeWE = new MouseCursor(IntPtr.Zero);
+            SizeNS = new MouseCursor(IntPtr.Zero);
+            SizeAll = new MouseCursor(IntPtr.Zero);
+            No = new MouseCursor(IntPtr.Zero);
+            Hand = new MouseCursor(IntPtr.Zero);
+        }
+
+        private static MouseCursor PlatformFromTexture2D(Texture2D texture, int originx, int originy)
+        {
+            return new MouseCursor(IntPtr.Zero);
+        }
+
+        private void PlatformDispose()
+        {
+        }
+    }
+}
diff --git a/MonoGame.Framework/Input/MouseCursor.SDL.cs b/MonoGame.Framework/Input/MouseCursor.SDL.cs
new file mode 100644
index 00000000000..9ec800aed1d
--- /dev/null
+++ b/MonoGame.Framework/Input/MouseCursor.SDL.cs
@@ -0,0 +1,69 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using Microsoft.Xna.Framework.Graphics;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public partial class MouseCursor
+    {
+        private MouseCursor(Sdl.Mouse.SystemCursor cursor)
+        {
+            Handle = Sdl.Mouse.CreateSystemCursor(cursor);
+        }
+
+        private static void PlatformInitalize()
+        {
+            Arrow = new MouseCursor(Sdl.Mouse.SystemCursor.Arrow);
+            IBeam = new MouseCursor(Sdl.Mouse.SystemCursor.IBeam);
+            Wait = new MouseCursor(Sdl.Mouse.SystemCursor.Wait);
+            Crosshair = new MouseCursor(Sdl.Mouse.SystemCursor.Crosshair);
+            WaitArrow = new MouseCursor(Sdl.Mouse.SystemCursor.WaitArrow);
+            SizeNWSE = new MouseCursor(Sdl.Mouse.SystemCursor.SizeNWSE);
+            SizeNESW = new MouseCursor(Sdl.Mouse.SystemCursor.SizeNESW);
+            SizeWE = new MouseCursor(Sdl.Mouse.SystemCursor.SizeWE);
+            SizeNS = new MouseCursor(Sdl.Mouse.SystemCursor.SizeNS);
+            SizeAll = new MouseCursor(Sdl.Mouse.SystemCursor.SizeAll);
+            No = new MouseCursor(Sdl.Mouse.SystemCursor.No);
+            Hand = new MouseCursor(Sdl.Mouse.SystemCursor.Hand);
+        }
+
+        private static MouseCursor PlatformFromTexture2D(Texture2D texture, int originx, int originy)
+        {
+            IntPtr surface = IntPtr.Zero;
+            IntPtr handle = IntPtr.Zero;
+            try
+            {
+                var bytes = new byte[texture.Width * texture.Height * 4];
+                texture.GetData(bytes);
+                surface = Sdl.CreateRGBSurfaceFrom(bytes, texture.Width, texture.Height, 32, texture.Width * 4, 0x000000ff, 0x0000FF00, 0x00FF0000, 0xFF000000);
+                if (surface == IntPtr.Zero)
+                    throw new InvalidOperationException("Failed to create surface for mouse cursor: " + Sdl.GetError());
+
+                handle = Sdl.Mouse.CreateColorCursor(surface, originx, originy);
+                if (handle == IntPtr.Zero)
+                    throw new InvalidOperationException("Failed to set surface for mouse cursor: " + Sdl.GetError());
+            }
+            finally
+            {
+                if (surface != IntPtr.Zero)
+                    Sdl.FreeSurface(surface);
+            }
+
+            return new MouseCursor(handle);
+        }
+
+        private void PlatformDispose()
+        {
+            if (Handle == IntPtr.Zero)
+                return;
+            
+            Sdl.Mouse.FreeCursor(Handle);
+            Handle = IntPtr.Zero;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Input/MouseCursor.Windows.cs b/MonoGame.Framework/Input/MouseCursor.Windows.cs
new file mode 100644
index 00000000000..60b9d0c336f
--- /dev/null
+++ b/MonoGame.Framework/Input/MouseCursor.Windows.cs
@@ -0,0 +1,97 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    public partial class MouseCursor
+    {
+        Cursor _cursor;
+        bool _needsDisposing;
+
+        internal Cursor Cursor { get { return _cursor; } }
+
+        private MouseCursor(Cursor cursor, bool needsDisposing = false)
+        {
+            _cursor = cursor;
+            _needsDisposing = needsDisposing;
+        }
+
+        private static void PlatformInitalize()
+        {
+            Arrow = new MouseCursor(Cursors.Arrow);
+            IBeam = new MouseCursor(Cursors.IBeam);
+            Wait = new MouseCursor(Cursors.WaitCursor);
+            Crosshair = new MouseCursor(Cursors.Cross);
+            WaitArrow = new MouseCursor(Cursors.AppStarting);
+            SizeNWSE = new MouseCursor(Cursors.SizeNWSE);
+            SizeNESW = new MouseCursor(Cursors.SizeNESW);
+            SizeWE = new MouseCursor(Cursors.SizeWE);
+            SizeNS = new MouseCursor(Cursors.SizeNS);
+            SizeAll = new MouseCursor(Cursors.SizeAll);
+            No = new MouseCursor(Cursors.No);
+            Hand = new MouseCursor(Cursors.Hand);
+        }
+
+        private static MouseCursor PlatformFromTexture2D(Texture2D texture, int originx, int originy)
+        {
+            var w = texture.Width;
+            var h = texture.Height;
+            Cursor cursor = null;
+            var bytes = new byte[w * h * 4];
+            texture.GetData(bytes);
+            var gcHandle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
+            try
+            {
+                using (var bitmap = new Bitmap(w, h, h * 4, PixelFormat.Format32bppArgb, gcHandle.AddrOfPinnedObject()))
+                {
+                    IconInfo iconInfo = new IconInfo();
+                    GetIconInfo(bitmap.GetHicon(), ref iconInfo);
+                    iconInfo.xHotspot = originx;
+                    iconInfo.yHotspot = originy;
+                    iconInfo.fIcon = false;
+                    cursor = new Cursor(CreateIconIndirect(ref iconInfo));
+                }
+            }
+            finally
+            {
+                gcHandle.Free();
+            }
+            return new MouseCursor(cursor, needsDisposing: true);
+        }
+
+        private void PlatformDispose()
+        {
+            if (_needsDisposing && _cursor != null)
+            {
+                _cursor.Dispose();
+                _cursor = null;
+                _needsDisposing = false;
+            }
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct IconInfo
+        {
+            public bool fIcon;
+            public int xHotspot;
+            public int yHotspot;
+            public IntPtr MaskBitmap;
+            public IntPtr ColorBitmap;
+        };
+
+        [DllImport("user32.dll")]
+        static extern IntPtr CreateIconIndirect([In] ref IconInfo iconInfo);
+
+        [DllImport("user32.dll")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        static extern bool GetIconInfo(IntPtr hIcon, ref IconInfo pIconInfo);
+    }
+}
diff --git a/MonoGame.Framework/Input/MouseCursor.cs b/MonoGame.Framework/Input/MouseCursor.cs
new file mode 100644
index 00000000000..1e0f26d5b05
--- /dev/null
+++ b/MonoGame.Framework/Input/MouseCursor.cs
@@ -0,0 +1,112 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Describes a mouse cursor.
+    /// </summary>
+    public partial class MouseCursor : IDisposable
+    {
+        /// <summary>
+        /// Gets the default arrow cursor.
+        /// </summary>
+        public static MouseCursor Arrow { get; private set; }
+
+        /// <summary>
+        /// Gets the cursor that appears when the mouse is over text editing regions.
+        /// </summary>
+        public static MouseCursor IBeam { get; private set; }
+
+        /// <summary>
+        /// Gets the waiting cursor that appears while the application/system is busy.
+        /// </summary>
+        public static MouseCursor Wait { get; private set; }
+
+        /// <summary>
+        /// Gets the crosshair ("+") cursor.
+        /// </summary>
+        public static MouseCursor Crosshair { get; private set; }
+
+        /// <summary>
+        /// Gets the cross between Arrow and Wait cursors.
+        /// </summary>
+        public static MouseCursor WaitArrow { get; private set; }
+
+        /// <summary>
+        /// Gets the northwest/southeast ("\") cursor.
+        /// </summary>
+        public static MouseCursor SizeNWSE { get; private set; }
+
+        /// <summary>
+        /// Gets the northeast/southwest ("/") cursor.
+        /// </summary>
+        public static MouseCursor SizeNESW { get; private set; }
+
+        /// <summary>
+        /// Gets the horizontal west/east ("-") cursor.
+        /// </summary>
+        public static MouseCursor SizeWE { get; private set; }
+
+        /// <summary>
+        /// Gets the vertical north/south ("|") cursor.
+        /// </summary>
+        public static MouseCursor SizeNS { get; private set; }
+
+        /// <summary>
+        /// Gets the size all cursor which points in all directions.
+        /// </summary>
+        public static MouseCursor SizeAll { get; private set; }
+
+        /// <summary>
+        /// Gets the cursor that points that something is invalid, usually a cross.
+        /// </summary>
+        public static MouseCursor No { get; private set; }
+
+        /// <summary>
+        /// Gets the hand cursor, usually used for web links.
+        /// </summary>
+        public static MouseCursor Hand { get; private set; }
+
+        /// <summary>
+        /// Creates a mouse cursor from the specified texture.
+        /// </summary>
+        /// <param name="texture">Texture to use as the cursor image.</param>
+        /// <param name="originx">X cordinate of the image that will be used for mouse position.</param>
+        /// <param name="originy">Y cordinate of the image that will be used for mouse position.</param>
+        public static MouseCursor FromTexture2D(Texture2D texture, int originx, int originy)
+        {
+            if (texture.Format != SurfaceFormat.Color && texture.Format != SurfaceFormat.ColorSRgb)
+                throw new ArgumentException("Only Color or ColorSrgb textures are accepted for mouse cursors", "texture");
+
+            return PlatformFromTexture2D(texture, originx, originy);
+        }
+
+        public IntPtr Handle { get; private set; }
+
+        private bool _disposed;
+
+        static MouseCursor()
+        {
+            PlatformInitalize();
+        }
+
+        private MouseCursor(IntPtr handle)
+        {
+            Handle = handle;
+        }
+
+        public void Dispose()
+        {
+            if (_disposed)
+                return;
+
+            PlatformDispose();
+            _disposed = true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Input/MouseState.cs b/MonoGame.Framework/Input/MouseState.cs
new file mode 100644
index 00000000000..41cf5a0d133
--- /dev/null
+++ b/MonoGame.Framework/Input/MouseState.cs
@@ -0,0 +1,258 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Represents a mouse state with cursor position and button press information.
+    /// </summary>
+    public struct MouseState
+    {
+        int _x, _y;
+        int _scrollWheelValue;
+        ButtonState _leftButton;
+        ButtonState _rightButton;
+        ButtonState _middleButton;
+        ButtonState _xButton1;
+        ButtonState _xButton2;
+        int _horizontalScrollWheelValue;
+
+        /// <summary>
+        /// Initializes a new instance of the MouseState.
+        /// </summary>
+        /// <param name="x">Horizontal position of the mouse in relation to the window.</param>
+        /// <param name="y">Vertical position of the mouse in relation to the window.</param>
+        /// <param name="scrollWheel">Mouse scroll wheel's value.</param>
+        /// <param name="leftButton">Left mouse button's state.</param>
+        /// <param name="middleButton">Middle mouse button's state.</param>
+        /// <param name="rightButton">Right mouse button's state.</param>
+        /// <param name="xButton1">XBUTTON1's state.</param>
+        /// <param name="xButton2">XBUTTON2's state.</param>
+        /// <remarks>Normally <see cref="Mouse.GetState()"/> should be used to get mouse current state. The constructor is provided for simulating mouse input.</remarks>
+        public MouseState(
+            int x,
+            int y,
+            int scrollWheel,
+            ButtonState leftButton,
+            ButtonState middleButton,
+            ButtonState rightButton,
+            ButtonState xButton1,
+            ButtonState xButton2)
+        {
+            _x = x;
+            _y = y;
+            _scrollWheelValue = scrollWheel;
+            _leftButton = leftButton;
+            _middleButton = middleButton;
+            _rightButton = rightButton;
+            _xButton1 = xButton1;
+            _xButton2 = xButton2;
+            _horizontalScrollWheelValue = 0;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the MouseState.
+        /// </summary>
+        /// <param name="x">Horizontal position of the mouse in relation to the window.</param>
+        /// <param name="y">Vertical position of the mouse in relation to the window.</param>
+        /// <param name="scrollWheel">Mouse scroll wheel's value.</param>
+        /// <param name="leftButton">Left mouse button's state.</param>
+        /// <param name="middleButton">Middle mouse button's state.</param>
+        /// <param name="rightButton">Right mouse button's state.</param>
+        /// <param name="xButton1">XBUTTON1's state.</param>
+        /// <param name="xButton2">XBUTTON2's state.</param>
+        /// <param name="horizontalScrollWheel">Mouse horizontal scroll wheel's value.</param>
+        /// <remarks>Normally <see cref="Mouse.GetState()"/> should be used to get mouse current state. The constructor is provided for simulating mouse input.</remarks>
+        public MouseState(
+            int x,
+            int y,
+            int scrollWheel,
+            ButtonState leftButton,
+            ButtonState middleButton,
+            ButtonState rightButton,
+            ButtonState xButton1,
+            ButtonState xButton2,
+            int horizontalScrollWheel)
+        {
+            _x = x;
+            _y = y;
+            _scrollWheelValue = scrollWheel;
+            _leftButton = leftButton;
+            _middleButton = middleButton;
+            _rightButton = rightButton;
+            _xButton1 = xButton1;
+            _xButton2 = xButton2;
+            _horizontalScrollWheelValue = horizontalScrollWheel;
+        }
+		
+        /// <summary>
+        /// Compares whether two MouseState instances are equal.
+        /// </summary>
+        /// <param name="left">MouseState instance on the left of the equal sign.</param>
+        /// <param name="right">MouseState instance  on the right of the equal sign.</param>
+        /// <returns>true if the instances are equal; false otherwise.</returns>
+		public static bool operator ==(MouseState left, MouseState right)
+		{
+			return left._x == right._x &&
+                   left._y == right._y &&
+                   left._leftButton == right._leftButton &&
+                   left._middleButton == right._middleButton &&
+                   left._rightButton == right._rightButton &&
+                   left._scrollWheelValue == right._scrollWheelValue &&
+                   left._horizontalScrollWheelValue == right._horizontalScrollWheelValue &&
+                   left._xButton1 == right._xButton1 &&
+                   left._xButton2 == right._xButton2;
+		}
+		
+        /// <summary>
+        /// Compares whether two MouseState instances are not equal.
+        /// </summary>
+        /// <param name="left">MouseState instance on the left of the equal sign.</param>
+        /// <param name="right">MouseState instance  on the right of the equal sign.</param>
+        /// <returns>true if the objects are not equal; false otherwise.</returns>
+		public static bool operator !=(MouseState left, MouseState right)
+		{
+			return !(left == right);
+		}
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified object.
+        /// </summary>
+        /// <param name="obj">The MouseState to compare.</param>
+        /// <returns></returns>
+        public override bool Equals(object obj)
+        {
+            if (obj is MouseState)
+                return this == (MouseState)obj;
+            return false;
+        }
+
+        /// <summary>
+        /// Gets the hash code for MouseState instance.
+        /// </summary>
+        /// <returns>Hash code of the object.</returns>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = _x;
+                hashCode = (hashCode*397) ^ _y;
+                hashCode = (hashCode*397) ^ _scrollWheelValue;
+                hashCode = (hashCode*397) ^ _horizontalScrollWheelValue;
+                hashCode = (hashCode*397) ^ (int) _leftButton;
+                hashCode = (hashCode*397) ^ (int) _rightButton;
+                hashCode = (hashCode*397) ^ (int) _middleButton;
+                hashCode = (hashCode*397) ^ (int) _xButton1;
+                hashCode = (hashCode*397) ^ (int) _xButton2;
+                return hashCode;
+            }
+        }
+
+        /// <summary>
+        /// Gets horizontal position of the cursor in relation to the window.
+        /// </summary>
+		public int X {
+			get {
+				return _x;
+			}
+			internal set {
+				_x = value;
+			}
+		}
+
+        /// <summary>
+        /// Gets vertical position of the cursor in relation to the window.
+        /// </summary>
+		public int Y {
+			get {
+				return _y;
+			}
+			internal set {
+				_y = value;
+			}
+        }
+
+        /// <summary>
+        /// Gets cursor position.
+        /// </summary>
+        public Point Position
+        {
+            get { return new Point(_x, _y); }   
+        }
+        /// <summary>
+        /// Gets state of the left mouse button.
+        /// </summary>
+		public ButtonState LeftButton { 
+			get {
+				return _leftButton;
+			}
+			internal set { _leftButton = value; }
+		}
+
+        /// <summary>
+        /// Gets state of the middle mouse button.
+        /// </summary>
+		public ButtonState MiddleButton { 
+			get {
+				return _middleButton;
+			}
+			internal set { _middleButton = value; }			
+		}
+
+        /// <summary>
+        /// Gets state of the right mouse button.
+        /// </summary>
+		public ButtonState RightButton { 
+			get {
+				return _rightButton;
+			}
+			internal set { _rightButton = value; }
+		}
+
+        /// <summary>
+        /// Returns cumulative scroll wheel value since the game start.
+        /// </summary>
+		public int ScrollWheelValue { 
+			get {
+				return _scrollWheelValue;
+			}
+			internal set { _scrollWheelValue = value; }
+		}
+
+        /// <summary>
+        /// Returns the cumulative horizontal scroll wheel value since the game start
+        /// </summary>
+        public int HorizontalScrollWheelValue {
+            get {
+                return _horizontalScrollWheelValue;
+            }
+            internal set { _horizontalScrollWheelValue = value; }
+        }
+
+        /// <summary>
+        /// Gets state of the XButton1.
+        /// </summary>
+		public ButtonState XButton1 { 
+			get {
+                return _xButton1;
+			}
+            internal set {
+                _xButton1 = value;
+            }
+		}
+
+        /// <summary>
+        /// Gets state of the XButton2.
+        /// </summary>
+		public ButtonState XButton2 { 
+			get {
+                return _xButton2;
+			}
+            internal set {
+                _xButton2 = value;
+            }
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Input/Touch/GestureSample.cs b/MonoGame.Framework/Input/Touch/GestureSample.cs
new file mode 100644
index 00000000000..21622376497
--- /dev/null
+++ b/MonoGame.Framework/Input/Touch/GestureSample.cs
@@ -0,0 +1,148 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009-2010 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+using Microsoft.Xna.Framework;
+using System;
+
+namespace Microsoft.Xna.Framework.Input.Touch
+{
+    /// <summary>
+    /// Represents data from a multi-touch gesture over a span of time.
+    /// </summary>
+    public struct GestureSample
+    {
+        // attributes
+		private GestureType _gestureType;
+		private TimeSpan _timestamp;
+		private Vector2 _position;
+		private Vector2 _position2;
+		private Vector2 _delta;
+		private Vector2 _delta2;
+		
+		#region Properties
+
+        /// <summary>
+        /// Gets the type of the gesture.
+        /// </summary>
+        public GestureType GestureType
+        {
+            get
+            {
+				return this._gestureType;
+            }
+        }
+
+        /// <summary>
+        /// Gets the starting time for this multi-touch gesture sample.
+        /// </summary>
+        public TimeSpan Timestamp
+        {
+            get
+            {
+				return this._timestamp;
+            }
+        }
+
+        /// <summary>
+        /// Gets the position of the first touch-point in the gesture sample.
+        /// </summary>
+        public Vector2 Position
+        {
+            get
+            {
+				return this._position;
+            }
+        }
+
+        /// <summary>
+        /// Gets the position of the second touch-point in the gesture sample.
+        /// </summary>
+        public Vector2 Position2
+        {
+            get
+            {
+				return this._position2;
+            }
+        }
+
+        /// <summary>
+        /// Gets the delta information for the first touch-point in the gesture sample.
+        /// </summary>
+        public Vector2 Delta
+        {
+            get
+            {
+				return this._delta;
+            }
+        }
+
+        /// <summary>
+        /// Gets the delta information for the second touch-point in the gesture sample.
+        /// </summary>
+        public Vector2 Delta2
+        {
+            get
+            {
+				return this._delta2;
+            }
+        }
+		#endregion
+		
+        /// <summary>
+        /// Initializes a new <see cref="GestureSample"/>.
+        /// </summary>
+        /// <param name="gestureType"><see cref="GestureType"/></param>
+        /// <param name="timestamp"></param>
+        /// <param name="position"></param>
+        /// <param name="position2"></param>
+        /// <param name="delta"></param>
+        /// <param name="delta2"></param>
+        public GestureSample(GestureType gestureType, TimeSpan timestamp, Vector2 position, Vector2 position2, Vector2 delta, Vector2 delta2)
+        {
+			this._gestureType = gestureType;
+			this._timestamp = timestamp;
+			this._position = position;
+			this._position2 = position2;
+			this._delta = delta;
+			this._delta2 = delta2;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Input/Touch/GestureType.cs b/MonoGame.Framework/Input/Touch/GestureType.cs
new file mode 100644
index 00000000000..b0b61e50706
--- /dev/null
+++ b/MonoGame.Framework/Input/Touch/GestureType.cs
@@ -0,0 +1,103 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009-2010 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+using System;
+
+namespace Microsoft.Xna.Framework.Input.Touch
+{
+    /// <summary>
+    /// Enumuration of values that represent different gestures that can be processed by <see cref="TouchPanel.ReadGesture"/>.
+    /// </summary>
+	[Flags]
+    public enum GestureType
+    {
+        /// <summary>
+        /// No gestures.
+        /// </summary>
+        None = 0,
+        /// <summary>
+        /// The user touched a single point.
+        /// </summary>
+        Tap = 1,
+        /// <summary>
+        /// States completion of a drag gesture(VerticalDrag, HorizontalDrag, or FreeDrag).
+        /// </summary>
+        /// <remarks>No position or delta information is available for this sample.</remarks>
+		DragComplete = 2,	
+	    /// <summary>
+        /// States that a touch was combined with a quick swipe.
+	    /// </summary>    
+	    /// <remarks>Flicks does not contain position information. The velocity of it can be read from <see cref="GestureSample.Delta"/></remarks>
+        Flick = 4,
+        /// <summary>
+        /// The use touched a point and then performed a free-form drag.
+        /// </summary>
+        FreeDrag = 8,
+        /// <summary>        
+        /// The use touched a single point for approximately one second.
+        /// </summary>
+        /// <remarks>As this is a single event, it will not be contionusly fired while the user is holding the touch-point.</remarks>
+        Hold = 16,
+        /// <summary>
+        /// The user touched the screen and performed either left to right or right to left drag gesture.
+        /// </summary>
+        HorizontalDrag = 32,
+        /// <summary>
+        /// The user either converged or diverged two touch-points on the screen which is like a two-finger drag.
+        /// </summary>
+        /// <remarks>When this gesture-type is enabled and two fingers are down, it takes precedence over drag gestures.</remarks>
+        Pinch = 64,
+        /// <summary>
+        /// An in-progress pinch operation was completed.
+        /// </summary>
+        /// <remarks>No position or delta information is available for this sample.</remarks>
+        PinchComplete = 128,
+        /// <summary>
+        /// The user tapped the device twice which is always preceded by a Tap gesture.
+        /// </summary>
+        /// <remarks>If the time between two touchs are long enough, insted two seperate single Tap gestures will be generated.</remarks>
+        DoubleTap = 256,
+        /// <summary>
+        /// The user touched the screen and performed either top to bottom or bottom to top drag gesture.
+        /// </summary>
+        VerticalDrag = 512,
+    }
+}
+
diff --git a/MonoGame.Framework/Input/Touch/TouchCollection.cs b/MonoGame.Framework/Input/Touch/TouchCollection.cs
new file mode 100644
index 00000000000..cfc852c0344
--- /dev/null
+++ b/MonoGame.Framework/Input/Touch/TouchCollection.cs
@@ -0,0 +1,278 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Input.Touch
+{
+    /// <summary>
+    /// Provides state information for a touch screen enabled device.
+    /// </summary>
+    public struct TouchCollection : IList<TouchLocation>
+	{
+        private readonly TouchLocation[] _collection;
+
+        private TouchLocation[] Collection
+        {
+            get { return _collection ?? EmptyLocationArray; }
+        }
+
+        #region Properties
+
+        /// <summary>
+        /// States if a touch screen is available.
+        /// </summary>
+        public bool IsConnected { get { return TouchPanel.GetCapabilities().IsConnected; } }
+
+        private static readonly TouchLocation[] EmptyLocationArray = new TouchLocation[0];
+        internal static readonly TouchCollection Empty = new TouchCollection(EmptyLocationArray);
+
+		#endregion
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TouchCollection"/> with a pre-determined set of touch locations.
+        /// </summary>
+        /// <param name="touches">Array of <see cref="TouchLocation"/> items to initialize with.</param>
+        public TouchCollection(TouchLocation[] touches)
+        {
+            if (touches == null)
+                throw new ArgumentNullException("touches");
+
+            _collection = touches;
+        }
+
+        /// <summary>
+        /// Returns <see cref="TouchLocation"/> specified by ID.
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="touchLocation"></param>
+        /// <returns></returns>
+        public bool FindById(int id, out TouchLocation touchLocation)
+		{
+            for (var i = 0; i < Collection.Length; i++)
+            {
+                var location = Collection[i];
+                if (location.Id == id)
+                {
+                    touchLocation = location;
+                    return true;
+                }
+            }
+
+            touchLocation = default(TouchLocation);
+            return false;
+		}
+
+        #region IList<TouchLocation>
+
+        /// <summary>
+        /// States if touch collection is read only.
+        /// </summary>
+        public bool IsReadOnly
+        {
+            get { return true; }
+        }
+
+        /// <summary>
+        /// Returns the index of the first occurrence of specified <see cref="TouchLocation"/> item in the collection.
+        /// </summary>
+        /// <param name="item"><see cref="TouchLocation"/> to query.</param>
+        /// <returns></returns>
+        public int IndexOf(TouchLocation item)
+        {
+            for (var i = 0; i < Collection.Length; i++)
+            {
+                if (item == Collection[i])
+                    return i;
+            }
+
+            return -1;
+        }
+
+        /// <summary>
+        /// Inserts a <see cref="TouchLocation"/> item into the indicated position.
+        /// </summary>
+        /// <param name="index">The position to insert into.</param>
+        /// <param name="item">The <see cref="TouchLocation"/> item to insert.</param>
+        public void Insert(int index, TouchLocation item)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Removes the <see cref="TouchLocation"/> item at specified index.
+        /// </summary>
+        /// <param name="index">Index of the item that will be removed from collection.</param>
+        public void RemoveAt(int index)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Gets or sets the item at the specified index of the collection.
+        /// </summary>
+        /// <param name="index">Position of the item.</param>
+        /// <returns><see cref="TouchLocation"/></returns>
+        public TouchLocation this[int index]
+        {
+            get
+            {
+                return Collection[index];
+            }
+            set
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        /// <summary>
+        /// Adds a <see cref="TouchLocation"/> to the collection.
+        /// </summary>
+        /// <param name="item">The <see cref="TouchLocation"/> item to be added. </param>
+        public void Add(TouchLocation item)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Clears all the items in collection.
+        /// </summary>
+        public void Clear()
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Returns true if specified <see cref="TouchLocation"/> item exists in the collection, false otherwise./>
+        /// </summary>
+        /// <param name="item">The <see cref="TouchLocation"/> item to query for.</param>
+        /// <returns>Returns true if queried item is found, false otherwise.</returns>
+        public bool Contains(TouchLocation item)
+        {
+            for (var i = 0; i < Collection.Length; i++)
+            {
+                if (item == Collection[i])
+                    return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Copies the <see cref="TouchLocation"/>collection to specified array starting from the given index.
+        /// </summary>
+        /// <param name="array">The array to copy <see cref="TouchLocation"/> items.</param>
+        /// <param name="arrayIndex">The starting index of the copy operation.</param>
+        public void CopyTo(TouchLocation[] array, int arrayIndex)
+        {
+            Collection.CopyTo(array, arrayIndex);
+        }
+
+        /// <summary>
+        /// Returns the number of <see cref="TouchLocation"/> items that exist in the collection.
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                return Collection.Length;
+            }
+        }
+
+        /// <summary>
+        /// Removes the specified <see cref="TouchLocation"/> item from the collection.
+        /// </summary>
+        /// <param name="item">The <see cref="TouchLocation"/> item to remove.</param>
+        /// <returns></returns>
+        public bool Remove(TouchLocation item)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Returns an enumerator for the <see cref="TouchCollection"/>.
+        /// </summary>
+        /// <returns>Enumerable list of <see cref="TouchLocation"/> objects.</returns>
+        public Enumerator GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        /// <summary>
+        /// Returns an enumerator for the <see cref="TouchCollection"/>.
+        /// </summary>
+        /// <returns>Enumerable list of <see cref="TouchLocation"/> objects.</returns>
+        IEnumerator<TouchLocation> IEnumerable<TouchLocation>.GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        /// <summary>
+        /// Returns an enumerator for the <see cref="TouchCollection"/>.
+        /// </summary>
+        /// <returns>Enumerable list of objects.</returns>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return new Enumerator(this);
+        }
+
+        #endregion // IList<TouchLocation>
+
+        /// <summary>
+        /// Provides the ability to iterate through the TouchLocations in an TouchCollection.
+        /// </summary>
+        public struct Enumerator : IEnumerator<TouchLocation>
+        {
+            private readonly TouchCollection _collection;
+            private int _position;
+
+            internal Enumerator(TouchCollection collection)
+            {
+                _collection = collection;
+                _position = -1;
+            }
+
+            /// <summary>
+            /// Gets the current element in the TouchCollection.
+            /// </summary>
+            public TouchLocation Current { get { return _collection[_position]; } }
+
+            /// <summary>
+            /// Advances the enumerator to the next element of the TouchCollection.
+            /// </summary>
+            public bool MoveNext()
+            {
+                _position++;
+                return (_position < _collection.Count);
+            }
+
+            #region IDisposable
+
+            /// <summary>
+            /// Immediately releases the unmanaged resources used by this object.
+            /// </summary>
+            public void Dispose()
+            {
+            }
+
+            #endregion
+
+            #region IEnumerator Members
+
+            object IEnumerator.Current
+            {
+                get { return _collection[_position]; }
+            }
+
+            public void Reset()
+            {
+                _position = -1;
+            }
+
+            #endregion
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Input/Touch/TouchLocation.cs b/MonoGame.Framework/Input/Touch/TouchLocation.cs
new file mode 100644
index 00000000000..b8aa8700bc9
--- /dev/null
+++ b/MonoGame.Framework/Input/Touch/TouchLocation.cs
@@ -0,0 +1,348 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009-2010 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+#region Using clause
+using System;
+using System.Diagnostics;
+#endregion Using clause
+
+
+namespace Microsoft.Xna.Framework.Input.Touch
+{
+    public struct TouchLocation : IEquatable<TouchLocation>
+    {
+		/// <summary>
+		///Attributes 
+		/// </summary>
+		private int _id;
+		private Vector2 _position;
+		private Vector2 _previousPosition;
+		private TouchLocationState _state;
+		private TouchLocationState _previousState;
+
+		// Only used in Android, for now
+		private float _pressure;
+		private float _previousPressure;
+
+        // Used for gesture recognition.
+        private Vector2 _velocity;
+        private Vector2 _pressPosition;
+        private TimeSpan _pressTimestamp;
+        private TimeSpan _timestamp;
+
+        /// <summary>
+        /// True if this touch was pressed and released on the same frame.
+        /// In this case we will keep it around for the user to get by GetState that frame.
+        /// However if they do not call GetState that frame, this touch will be forgotten.
+        /// </summary>
+        internal bool SameFrameReleased;
+
+        /// <summary>
+        /// Helper for assigning an invalid touch location.
+        /// </summary>
+        internal static readonly TouchLocation Invalid = new TouchLocation();
+
+		#region Properties
+
+        internal Vector2 PressPosition
+        {
+            get { return _pressPosition; }
+        }
+
+        internal TimeSpan PressTimestamp
+        {
+            get { return _pressTimestamp; }
+        }
+
+        internal TimeSpan Timestamp
+        {
+            get { return _timestamp; }
+        }
+
+        internal Vector2 Velocity
+        {
+            get { return _velocity; }
+        }
+
+		public int Id 
+		{ 
+			get
+	        {
+	            return _id;
+	        }
+		}
+
+        public Vector2 Position 
+		{ 
+			get
+	        {
+	            return _position;
+	        }
+		}
+		
+		public float Pressure 
+		{ 
+			get
+        	{
+            	return _pressure;
+        	}
+		}
+								
+        public TouchLocationState State 
+		{ 
+			get
+	        {
+	            return _state;
+	        } 
+		}
+		
+		#endregion
+		
+		#region Constructors
+
+        public TouchLocation(int id, TouchLocationState state, Vector2 position)
+            : this(id, state, position, TouchLocationState.Invalid, Vector2.Zero)
+        {
+        }
+
+        public TouchLocation(   int id, TouchLocationState state, Vector2 position, 
+                                TouchLocationState previousState, Vector2 previousPosition)
+            : this(id, state, position, previousState, previousPosition, TimeSpan.Zero)
+        {
+        }
+
+        internal TouchLocation(int id, TouchLocationState state, Vector2 position, TimeSpan timestamp)
+            : this(id, state, position, TouchLocationState.Invalid, Vector2.Zero, timestamp)
+        {
+        }
+
+        internal TouchLocation(int id, TouchLocationState state, Vector2 position,
+            TouchLocationState previousState, Vector2 previousPosition, TimeSpan timestamp)
+        {
+            _id = id;
+            _state = state;
+            _position = position;
+            _pressure = 0.0f;
+
+            _previousState = previousState;
+            _previousPosition = previousPosition;
+            _previousPressure = 0.0f;
+
+            _timestamp = timestamp;
+            _velocity = Vector2.Zero;
+
+            // If this is a pressed location then store the 
+            // current position and timestamp as pressed.
+            if (state == TouchLocationState.Pressed)
+            {
+                _pressPosition = _position;
+                _pressTimestamp = _timestamp;
+            }
+            else
+            {
+                _pressPosition = Vector2.Zero;
+                _pressTimestamp = TimeSpan.Zero;
+            }
+
+            SameFrameReleased = false;
+        }
+
+		#endregion
+
+        /// <summary>
+        /// Returns a copy of the touch with the state changed to moved.
+        /// </summary>
+        /// <returns>The new touch location.</returns>
+        internal TouchLocation AsMovedState()
+        {
+            var touch = this;
+
+            // Store the current state as the previous.
+            touch._previousState = touch._state;
+            touch._previousPosition = touch._position;
+            touch._previousPressure = touch._pressure;
+
+            // Set the new state.
+            touch._state = TouchLocationState.Moved;
+            
+            return touch;
+        }
+
+        /// <summary>
+        /// Updates the touch location using the new event.
+        /// </summary>
+        /// <param name="touchEvent">The next event for this touch location.</param>
+        internal bool UpdateState(TouchLocation touchEvent)
+        {
+            Debug.Assert(Id == touchEvent.Id, "The touch event must have the same Id!");
+            Debug.Assert(State != TouchLocationState.Released, "We shouldn't be changing state on a released location!");
+            Debug.Assert(   touchEvent.State == TouchLocationState.Moved ||
+                            touchEvent.State == TouchLocationState.Released, "The new touch event should be a move or a release!");
+            Debug.Assert(touchEvent.Timestamp >= _timestamp, "The touch event is older than our timestamp!");
+
+            // Store the current state as the previous one.
+            _previousPosition = _position;
+            _previousState = _state;
+            _previousPressure = _pressure;
+
+            // Set the new state.
+            _position = touchEvent._position;
+            if (touchEvent.State == TouchLocationState.Released)
+                _state = touchEvent._state;
+            _pressure = touchEvent._pressure;
+
+            // If time has elapsed then update the velocity.
+            var delta = _position - _previousPosition;
+            var elapsed = touchEvent.Timestamp - _timestamp;
+            if (elapsed > TimeSpan.Zero)
+            {
+                // Use a simple low pass filter to accumulate velocity.
+                var velocity = delta / (float)elapsed.TotalSeconds;
+                _velocity += (velocity - _velocity) * 0.45f;
+            }
+
+            //Going straight from pressed to released on the same frame
+            if (_previousState == TouchLocationState.Pressed && _state == TouchLocationState.Released && elapsed == TimeSpan.Zero)
+            {
+                //Lie that we are pressed for now
+                SameFrameReleased = true;
+                _state = TouchLocationState.Pressed;
+            }
+
+            // Set the new timestamp.
+            _timestamp = touchEvent.Timestamp;
+
+            // Return true if the state actually changed.
+            return _state != _previousState || delta.LengthSquared() > 0.001f;
+        }
+
+        public override bool Equals(object obj)
+        {
+			if (obj is TouchLocation)
+				return Equals((TouchLocation)obj);
+
+			return false;
+		}
+
+        public bool Equals(TouchLocation other)
+        {
+            return  _id.Equals(other._id) &&
+                    _position.Equals(other._position) &&
+                    _previousPosition.Equals(other._previousPosition);
+        }
+
+        public override int GetHashCode()
+        {
+            return _id;
+        }
+
+        public override string ToString()
+        {
+            return "Touch id:"+_id+" state:"+_state + " position:" + _position + " pressure:" + _pressure +" prevState:"+_previousState+" prevPosition:"+ _previousPosition + " previousPressure:" + _previousPressure;
+        }
+
+        public bool TryGetPreviousLocation(out TouchLocation aPreviousLocation)
+        {
+			if (_previousState == TouchLocationState.Invalid)
+			{
+				aPreviousLocation._id = -1;
+				aPreviousLocation._state = TouchLocationState.Invalid;
+                aPreviousLocation._position = Vector2.Zero;
+				aPreviousLocation._previousState = TouchLocationState.Invalid;
+				aPreviousLocation._previousPosition = Vector2.Zero; 
+				aPreviousLocation._pressure = 0.0f;
+				aPreviousLocation._previousPressure = 0.0f;
+			    aPreviousLocation._timestamp = TimeSpan.Zero;
+			    aPreviousLocation._pressPosition = Vector2.Zero;
+			    aPreviousLocation._pressTimestamp = TimeSpan.Zero;
+                aPreviousLocation._velocity = Vector2.Zero;
+                aPreviousLocation.SameFrameReleased = false;
+                return false;
+			}
+
+			aPreviousLocation._id = _id;
+			aPreviousLocation._state = _previousState;
+			aPreviousLocation._position = _previousPosition;
+			aPreviousLocation._previousState = TouchLocationState.Invalid;
+			aPreviousLocation._previousPosition = Vector2.Zero;
+			aPreviousLocation._pressure = _previousPressure;
+			aPreviousLocation._previousPressure = 0.0f;
+			aPreviousLocation._timestamp = _timestamp;
+            aPreviousLocation._pressPosition = _pressPosition;
+            aPreviousLocation._pressTimestamp = _pressTimestamp;
+            aPreviousLocation._velocity = _velocity;
+            aPreviousLocation.SameFrameReleased = SameFrameReleased;
+            return true;
+        }
+
+        public static bool operator !=(TouchLocation value1, TouchLocation value2)
+        {
+			return  value1._id != value2._id || 
+			        value1._state != value2._state ||
+			        value1._position != value2._position ||
+			        value1._previousState != value2._previousState ||
+			        value1._previousPosition != value2._previousPosition;
+        }
+
+        public static bool operator ==(TouchLocation value1, TouchLocation value2)
+        {
+            return  value1._id == value2._id && 
+			        value1._state == value2._state &&
+			        value1._position == value2._position &&
+			        value1._previousState == value2._previousState &&
+			        value1._previousPosition == value2._previousPosition;
+        }
+
+
+        internal void AgeState()
+        {
+            Debug.Assert(_state == TouchLocationState.Pressed, "Can only age the state of touches that are in the Pressed State");
+
+            _previousState = _state;
+            _previousPosition = _position;
+            _previousPressure = _pressure;
+
+            if (SameFrameReleased)
+                _state = TouchLocationState.Released;
+            else
+                _state = TouchLocationState.Moved;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Input/Touch/TouchLocationState.cs b/MonoGame.Framework/Input/Touch/TouchLocationState.cs
new file mode 100644
index 00000000000..d9052be82f1
--- /dev/null
+++ b/MonoGame.Framework/Input/Touch/TouchLocationState.cs
@@ -0,0 +1,70 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009-2010 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+#region Using clause
+using System;
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Input.Touch
+{
+    /// <summary>
+    /// Holds the possible state information for a touch location..
+    /// </summary>
+    public enum TouchLocationState
+    {
+        /// <summary>
+        /// This touch location position is invalid.
+        /// </summary>
+        /// <remarks>Typically, you will encounter this state when a new touch location attempts to get the previous state of itself.</remarks>
+        Invalid,    
+        /// <summary>
+        /// This touch location position was updated or pressed at the same position.
+        /// </summary>
+        Moved,
+        /// <summary>
+        /// This touch location position is new. 
+        /// </summary>
+        Pressed,
+        /// <summary>
+        /// This touch location position was released. 
+        /// </summary>
+        Released,
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Input/Touch/TouchPanel.cs b/MonoGame.Framework/Input/Touch/TouchPanel.cs
new file mode 100644
index 00000000000..27cf2866f26
--- /dev/null
+++ b/MonoGame.Framework/Input/Touch/TouchPanel.cs
@@ -0,0 +1,156 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// XnaTouch - Copyright © 2009-2010 The XnaTouch Team
+//
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+using System;
+
+namespace Microsoft.Xna.Framework.Input.Touch
+{
+    /// <summary>
+    /// Allows retrieval of information from Touch Panel device.
+    /// </summary>
+    public static class TouchPanel
+    {
+        internal static GameWindow PrimaryWindow;
+
+        /// <summary>
+        /// Gets the current state of the touch panel.
+        /// </summary>
+        /// <returns><see cref="TouchCollection"/></returns>
+        public static TouchCollection GetState()
+        {
+            return PrimaryWindow.TouchPanelState.GetState();
+        }
+
+        public static TouchPanelState GetState(GameWindow window)
+        {
+            return window.TouchPanelState;
+        }
+
+        public static TouchPanelCapabilities GetCapabilities()
+        {
+            return PrimaryWindow.TouchPanelState.GetCapabilities();
+        }
+
+        internal static void AddEvent(int id, TouchLocationState state, Vector2 position)
+        {
+            AddEvent(id, state, position, false);
+        }
+
+        internal static void AddEvent(int id, TouchLocationState state, Vector2 position, bool isMouse)
+        {
+            PrimaryWindow.TouchPanelState.AddEvent(id, state, position, isMouse);
+        }
+
+        /// <summary>
+        /// Returns the next available gesture on touch panel device.
+        /// </summary>
+        /// <returns><see cref="GestureSample"/></returns>
+		public static GestureSample ReadGesture()
+        {
+            // Return the next gesture.
+            return PrimaryWindow.TouchPanelState.GestureList.Dequeue();			
+        }
+
+        /// <summary>
+        /// The window handle of the touch panel. Purely for Xna compatibility.
+        /// </summary>
+        public static IntPtr WindowHandle
+        {
+            get { return PrimaryWindow.TouchPanelState.WindowHandle; }
+            set { PrimaryWindow.TouchPanelState.WindowHandle = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the display height of the touch panel.
+        /// </summary>
+        public static int DisplayHeight
+        {
+            get { return PrimaryWindow.TouchPanelState.DisplayHeight; }
+            set { PrimaryWindow.TouchPanelState.DisplayHeight = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the display orientation of the touch panel.
+        /// </summary>
+        public static DisplayOrientation DisplayOrientation
+        {
+            get { return PrimaryWindow.TouchPanelState.DisplayOrientation; }
+            set { PrimaryWindow.TouchPanelState.DisplayOrientation = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the display width of the touch panel.
+        /// </summary>
+        public static int DisplayWidth
+        {
+            get { return PrimaryWindow.TouchPanelState.DisplayWidth; }
+            set { PrimaryWindow.TouchPanelState.DisplayWidth = value; }
+        }
+		
+        /// <summary>
+        /// Gets or sets enabled gestures.
+        /// </summary>
+        public static GestureType EnabledGestures
+        {
+            get { return PrimaryWindow.TouchPanelState.EnabledGestures; }
+            set { PrimaryWindow.TouchPanelState.EnabledGestures = value; }
+        }
+
+        public static bool EnableMouseTouchPoint
+        {
+            get { return PrimaryWindow.TouchPanelState.EnableMouseTouchPoint; }
+            set { PrimaryWindow.TouchPanelState.EnableMouseTouchPoint = value; }
+        }
+
+        public static bool EnableMouseGestures
+        {
+            get { return PrimaryWindow.TouchPanelState.EnableMouseGestures; }
+            set { PrimaryWindow.TouchPanelState.EnableMouseGestures = value; }
+        }
+
+        /// <summary>
+        /// Returns true if a touch gesture is available.
+        /// </summary>
+        public static bool IsGestureAvailable
+        {
+            get { return PrimaryWindow.TouchPanelState.IsGestureAvailable; }
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Input/Touch/TouchPanelCapabilities.cs b/MonoGame.Framework/Input/Touch/TouchPanelCapabilities.cs
new file mode 100644
index 00000000000..a2fd6787e06
--- /dev/null
+++ b/MonoGame.Framework/Input/Touch/TouchPanelCapabilities.cs
@@ -0,0 +1,112 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+#if ANDROID
+using Android.Content.PM;
+#endif
+#if IOS
+using UIKit;
+#endif
+
+
+namespace Microsoft.Xna.Framework.Input.Touch
+{
+    /// <summary>
+    /// Allows retrieval of capabilities information from touch panel device.
+    /// </summary>
+    public struct TouchPanelCapabilities
+    {
+        private bool hasPressure;
+        private bool isConnected;
+        private int maximumTouchCount;
+        private bool initialized;
+
+        internal void Initialize()
+        {
+            if (!initialized)
+            {
+                initialized = true;
+
+                // There does not appear to be a way of finding out if a touch device supports pressure.
+                // XNA does not expose a pressure value, so let's assume it doesn't support it.
+                hasPressure = false;
+
+#if WINDOWS_UAP
+                // Is a touch device present?
+                // Iterate through all pointer devices and find the maximum number of concurrent touches possible
+                maximumTouchCount = 0;
+                var pointerDevices = Windows.Devices.Input.PointerDevice.GetPointerDevices();
+                foreach (var pointerDevice in pointerDevices)
+                {
+                    maximumTouchCount = Math.Max(maximumTouchCount, (int)pointerDevice.MaxContacts);
+
+                    if (pointerDevice.PointerDeviceType == Windows.Devices.Input.PointerDeviceType.Touch)
+                        isConnected = true;
+                }
+#elif WINDOWS
+                maximumTouchCount = GetSystemMetrics(SM_MAXIMUMTOUCHES);
+                isConnected = (maximumTouchCount > 0);
+#elif ANDROID
+                // http://developer.android.com/reference/android/content/pm/PackageManager.html#FEATURE_TOUCHSCREEN
+                var pm = Game.Activity.PackageManager;
+                isConnected = pm.HasSystemFeature(PackageManager.FeatureTouchscreen);
+                if (pm.HasSystemFeature(PackageManager.FeatureTouchscreenMultitouchJazzhand))
+                    maximumTouchCount = 5;
+                else if (pm.HasSystemFeature(PackageManager.FeatureTouchscreenMultitouchDistinct))
+                    maximumTouchCount = 2;
+                else
+                    maximumTouchCount = 1;
+#elif IOS
+                //iPhone supports 5, iPad 11
+                isConnected = true;
+                if (UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Phone)
+                    maximumTouchCount = 5;
+                else //Pad
+                    maximumTouchCount = 11;
+#else
+                //Touch isn't implemented in OpenTK, so no linux or mac https://github.com/opentk/opentk/issues/80
+                isConnected = false;
+#endif
+            }
+        }
+
+        public bool HasPressure
+        {
+            get
+            {
+                return hasPressure;
+            }
+        }
+
+        /// <summary>
+        /// Returns true if a device is available for use.
+        /// </summary>
+        public bool IsConnected
+        {
+            get
+            {
+                return isConnected;
+            }
+        }
+
+        /// <summary>
+        /// Returns the maximum number of touch locations tracked by the touch panel device.
+        /// </summary>
+        public int MaximumTouchCount
+        {
+            get
+            {
+                return maximumTouchCount;
+            }
+        }
+
+#if WINDOWS
+        [System.Runtime.InteropServices.DllImport("user32.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto, ExactSpelling = true)]
+        static extern int GetSystemMetrics(int nIndex);
+
+        const int SM_MAXIMUMTOUCHES = 95;
+#endif
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Input/Touch/TouchPanelState.cs b/MonoGame.Framework/Input/Touch/TouchPanelState.cs
new file mode 100644
index 00000000000..1aa7bf2ec2a
--- /dev/null
+++ b/MonoGame.Framework/Input/Touch/TouchPanelState.cs
@@ -0,0 +1,734 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Input.Touch
+{
+    public class TouchPanelState
+    {
+        /// <summary>
+        /// The reserved touchId for all mouse touch points.
+        /// </summary>
+        private const int MouseTouchId = 1;
+
+        /// <summary>
+        /// The current touch state.
+        /// </summary>
+        private readonly List<TouchLocation> _touchState = new List<TouchLocation>();
+
+        /// <summary>
+        /// The current gesture state.
+        /// </summary>
+        private readonly List<TouchLocation> _gestureState = new List<TouchLocation>();
+
+        /// <summary>
+        /// The positional scale to apply to touch input.
+        /// </summary>
+        private Vector2 _touchScale = Vector2.One;
+
+        /// <summary>
+        /// The current size of the display.
+        /// </summary>
+        private Point _displaySize = Point.Zero;
+
+        /// <summary>
+        /// The next touch location identifier.
+        /// The value 1 is reserved for the mouse touch point.
+        /// </summary>
+        private int _nextTouchId = 2;
+
+        /// <summary>
+        /// The current timestamp that we use for setting the timestamp of new TouchLocations
+        /// </summary>
+        internal static TimeSpan CurrentTimestamp { get; set; }
+
+        /// <summary>
+        /// The mapping between platform specific touch ids
+        /// and the touch ids we assign to touch locations.
+        /// </summary>
+        private readonly Dictionary<int, int> _touchIds = new Dictionary<int, int>();
+
+        internal readonly Queue<GestureSample> GestureList = new Queue<GestureSample>();
+
+        private TouchPanelCapabilities Capabilities = new TouchPanelCapabilities();
+
+        internal readonly GameWindow Window;
+
+        internal TouchPanelState(GameWindow window)
+        {
+            Window = window;
+        }
+
+        /// <summary>
+        /// The window handle of the touch panel. Purely for Xna compatibility.
+        /// </summary>
+        public IntPtr WindowHandle { get; set; }
+
+        /// <summary>
+        /// Returns capabilities of touch panel device.
+        /// </summary>
+        /// <returns><see cref="TouchPanelCapabilities"/></returns>
+        public TouchPanelCapabilities GetCapabilities()
+        {
+            Capabilities.Initialize();
+            return Capabilities;
+        }
+
+        /// <summary>
+        /// Age all the touches, so any that were Pressed become Moved, and any that were Released are removed
+        /// </summary>
+        private void AgeTouches(List<TouchLocation> state)
+        {
+            for (var i = state.Count - 1; i >= 0; i--)
+            {
+                var touch = state[i];
+                if (touch.State == TouchLocationState.Released)
+                {
+                    state.RemoveAt(i);
+                }
+                else if (touch.State == TouchLocationState.Pressed)
+                {
+                    touch.AgeState();
+                    state[i] = touch;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Apply the given new touch to the state. If it is a Pressed it will be added as a new touch, otherwise we update the existing touch it matches
+        /// </summary>
+        private void ApplyTouch(List<TouchLocation> state, TouchLocation touch)
+        {
+            if (touch.State == TouchLocationState.Pressed)
+            {
+                state.Add(touch);
+                return;
+            }
+
+            //Find the matching touch
+            for (var i = 0; i < state.Count; i++)
+            {
+                var existingTouch = state[i];
+
+                if (existingTouch.Id == touch.Id)
+                {
+                    //If we are moving straight from Pressed to Released and we've existed for multiple frames, that means we've never been seen, so just get rid of us
+                    if (existingTouch.State == TouchLocationState.Pressed && touch.State == TouchLocationState.Released && existingTouch.PressTimestamp != touch.Timestamp)
+                    {
+                        state.RemoveAt(i);
+                    }
+                    else
+                    {
+                        //Otherwise update the touch based on the new one
+                        existingTouch.UpdateState(touch);
+                        state[i] = existingTouch;
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        public TouchCollection GetState()
+        {
+            //Clear out touches from previous frames that were released on the same frame they were touched that haven't been seen
+            for (var i = _touchState.Count - 1; i >= 0; i--)
+            {
+                var touch = _touchState[i];
+
+                //If a touch was pressed and released in a previous frame and the user didn't ask about it then trash it.
+                if (touch.SameFrameReleased && touch.Timestamp < CurrentTimestamp && touch.State == TouchLocationState.Pressed)
+                {
+                    _touchState.RemoveAt(i);
+                }
+            }
+
+            var result = (_touchState.Count > 0) ? new TouchCollection(_touchState.ToArray()) : TouchCollection.Empty;
+            AgeTouches(_touchState);
+            return result;
+        }
+
+        internal void AddEvent(int id, TouchLocationState state, Vector2 position)
+        {
+            AddEvent(id, state, position, false);
+        }
+
+        internal void AddEvent(int id, TouchLocationState state, Vector2 position, bool isMouse)
+        {
+            // Different platforms return different touch identifiers
+            // based on the specifics of their implementation and the
+            // system drivers.
+            //
+            // Sometimes these ids are suitable for our use, but other
+            // times it can recycle ids or do cute things like return
+            // the same id for double tap events.
+            //
+            // We instead provide consistent ids by generating them
+            // ourselves on the press and looking them up on move 
+            // and release events.
+            // 
+            if (state == TouchLocationState.Pressed)
+            {
+                if (isMouse)
+                {
+                    // Mouse pointing devices always use a reserved Id
+                    _touchIds[id] = MouseTouchId;
+                }
+                else
+                {
+                    _touchIds[id] = _nextTouchId++;
+                }
+            }
+
+            // Try to find the touch id.
+            int touchId;
+            if (!_touchIds.TryGetValue(id, out touchId))
+            {
+                // If we got here that means either the device is sending
+                // us bad, out of order, or old touch events.  In any case
+                // just ignore them.
+                return;
+            }
+
+            if (!isMouse || EnableMouseTouchPoint || EnableMouseGestures)
+            {
+                // Add the new touch event keeping the list from getting
+                // too large if no one happens to be requesting the state.
+                var evt = new TouchLocation(touchId, state, position * _touchScale, CurrentTimestamp);
+
+                if (!isMouse || EnableMouseTouchPoint)
+                {
+                    ApplyTouch(_touchState, evt);
+                }
+
+                //If we have gestures enabled then collect events for those too.
+                //We also have to keep tracking any touches while we know about touches so we don't miss releases even if gesture recognition is disabled
+                if ((EnabledGestures != GestureType.None || _gestureState.Count > 0) && (!isMouse || EnableMouseGestures))
+                {
+                    ApplyTouch(_gestureState, evt);
+
+                    if (EnabledGestures != GestureType.None)
+                        UpdateGestures(true);
+
+                    AgeTouches(_gestureState);
+                }
+            }
+
+            // If this is a release unmap the hardware id.
+            if (state == TouchLocationState.Released)
+                _touchIds.Remove(id);
+        }
+
+        private void UpdateTouchScale()
+        {
+            // Get the window size.
+            var windowSize = new Vector2(Window.ClientBounds.Width, Window.ClientBounds.Height);
+
+            // Recalculate the touch scale.
+            _touchScale = new Vector2(  _displaySize.X / windowSize.X,
+                                        _displaySize.Y / windowSize.Y);
+        }
+
+        /// <summary>
+        /// This will release all touch locations.  It should only be 
+        /// called on platforms where touch state is reset all at once.
+        /// </summary>
+        internal void ReleaseAllTouches()
+        {
+            var mostToRemove = Math.Max(_touchState.Count, _gestureState.Count);
+            if (mostToRemove > 0)
+            {
+                var temp = new List<TouchLocation>(mostToRemove);
+
+                // Submit a new event for each non-released location.
+                temp.AddRange(_touchState);
+                foreach (var touch in temp)
+                {
+                    if (touch.State != TouchLocationState.Released)
+                        ApplyTouch(_touchState, new TouchLocation(touch.Id, TouchLocationState.Released, touch.Position, CurrentTimestamp));
+                }
+
+                temp.Clear();
+                temp.AddRange(_gestureState);
+                foreach (var touch in temp)
+                {
+                    if (touch.State != TouchLocationState.Released)
+                        ApplyTouch(_gestureState, new TouchLocation(touch.Id, TouchLocationState.Released, touch.Position, CurrentTimestamp));
+                }
+            }
+
+            // Release all the touch id mappings.
+            _touchIds.Clear();
+        }
+
+        /// <summary>
+        /// Gets or sets the display height of the touch panel.
+        /// </summary>
+        public int DisplayHeight
+        {
+            get
+            {
+                return _displaySize.Y;
+            }
+            set
+            {
+                _displaySize.Y = value;
+                UpdateTouchScale();
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the display orientation of the touch panel.
+        /// </summary>
+        public DisplayOrientation DisplayOrientation { get; set; }
+
+        /// <summary>
+        /// Gets or sets the display width of the touch panel.
+        /// </summary>
+        public int DisplayWidth
+        {
+            get
+            {
+                return _displaySize.X;
+            }
+            set
+            {
+                _displaySize.X = value;
+                UpdateTouchScale();
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets enabled gestures.
+        /// </summary>
+        public GestureType EnabledGestures { get; set; }
+
+        public bool EnableMouseTouchPoint { get; set; }
+
+        public bool EnableMouseGestures { get; set; }
+
+        /// <summary>
+        /// Returns true if a touch gesture is available.
+        /// </summary>
+        public bool IsGestureAvailable
+        {
+            get
+            {
+                // Process the pending gesture events. (May cause hold events)
+                UpdateGestures(false);
+
+                return GestureList.Count > 0;
+            }
+        }
+
+        /// <summary>
+        /// Returns the next available gesture on touch panel device.
+        /// </summary>
+        /// <returns><see cref="GestureSample"/></returns>
+        public GestureSample ReadGesture()
+        {
+            // Return the next gesture.
+            return GestureList.Dequeue();
+        }
+
+        #region Gesture Recognition
+
+        /// <summary>
+        /// Maximum distance a touch location can wiggle and 
+        /// not be considered to have moved.
+        /// </summary>
+        internal const float TapJitterTolerance = 35.0f;
+
+        internal static readonly TimeSpan TimeRequiredForHold = TimeSpan.FromMilliseconds(1024);
+
+        /// <summary>
+        /// The pinch touch locations.
+        /// </summary>
+        private readonly TouchLocation[] _pinchTouch = new TouchLocation[2];
+
+        /// <summary>
+        /// If true the pinch touch locations are valid and
+        /// a pinch gesture has begun.
+        /// </summary>
+        private bool _pinchGestureStarted;
+
+        private bool GestureIsEnabled(GestureType gestureType)
+        {
+            return (EnabledGestures & gestureType) != 0;
+        }
+
+        /// <summary>
+        /// Used to disable emitting of tap gestures.
+        /// </summary>
+        bool _tapDisabled;
+
+        /// <summary>
+        /// Used to disable emitting of hold gestures.
+        /// </summary>
+        bool _holdDisabled;
+
+
+        private void UpdateGestures(bool stateChanged)
+        {
+            // These are observed XNA gesture rules which we follow below.  Please
+            // add to them if a new case is found.
+            //
+            //  - Tap occurs on release.
+            //  - DoubleTap occurs on the first press after a Tap.
+            //  - Tap, Double Tap, and Hold are disabled if a drag begins or more than one finger is pressed.
+            //  - Drag occurs when one finger is down and actively moving.
+            //  - Pinch occurs if 2 or more fingers are down and at least one is moving.
+            //  - If you enter a Pinch during a drag a DragComplete is fired.
+            //  - Drags are classified as horizontal, vertical, free, or none and stay that way.
+            //
+
+            // First get a count of touch locations which 
+            // are not in the released state.
+            var heldLocations = 0;
+            foreach (var touch in _gestureState)
+                heldLocations += touch.State != TouchLocationState.Released ? 1 : 0;
+
+            // As soon as we have more than one held point then 
+            // tap and hold gestures are disabled until all the 
+            // points are released.
+            if (heldLocations > 1)
+            {
+                _tapDisabled = true;
+                _holdDisabled = true;
+            }
+
+            // Process the touch locations for gestures.
+            foreach (var touch in _gestureState)
+            {
+                switch (touch.State)
+                {
+                    case TouchLocationState.Pressed:
+                    case TouchLocationState.Moved:
+                        {
+                            // The DoubleTap event is emitted on first press as
+                            // opposed to Tap which happens on release.
+                            if (touch.State == TouchLocationState.Pressed &&
+                                ProcessDoubleTap(touch))
+                                break;
+
+                            // Any time more than one finger is down and pinch is
+                            // enabled then we exclusively do pinch processing.
+                            if (GestureIsEnabled(GestureType.Pinch) && heldLocations > 1)
+                            {
+                                // Save or update the first pinch point.
+                                if (_pinchTouch[0].State == TouchLocationState.Invalid ||
+                                        _pinchTouch[0].Id == touch.Id)
+                                    _pinchTouch[0] = touch;
+
+                                // Save or update the second pinch point.
+                                else if (_pinchTouch[1].State == TouchLocationState.Invalid ||
+                                            _pinchTouch[1].Id == touch.Id)
+                                    _pinchTouch[1] = touch;
+
+                                // NOTE: Actual pinch processing happens outside and
+                                // below this loop to ensure both points are updated
+                                // before gestures are emitted.
+                                break;
+                            }
+
+                            // If we're not dragging try to process a hold event.
+                            var dist = Vector2.Distance(touch.Position, touch.PressPosition);
+                            if (_dragGestureStarted == GestureType.None && dist < TapJitterTolerance)
+                            {
+                                ProcessHold(touch);
+                                break;
+                            }
+
+                            // If the touch state has changed then do a drag gesture.
+                            if (stateChanged)
+                                ProcessDrag(touch);
+                            break;
+                        }
+
+                    case TouchLocationState.Released:
+                        {
+                            // If the touch state hasn't changed then this
+                            // is an old release event... skip it.
+                            if (!stateChanged)
+                                break;
+
+                            // If this is one of the pinch locations then we
+                            // need to fire off the complete event and stop
+                            // the pinch gesture operation.
+                            if (_pinchGestureStarted &&
+                                    (touch.Id == _pinchTouch[0].Id ||
+                                        touch.Id == _pinchTouch[1].Id))
+                            {
+                                if (GestureIsEnabled(GestureType.PinchComplete))
+                                    GestureList.Enqueue(new GestureSample(
+                                                            GestureType.PinchComplete, touch.Timestamp,
+                                                            Vector2.Zero, Vector2.Zero,
+                                                            Vector2.Zero, Vector2.Zero));
+
+                                _pinchGestureStarted = false;
+                                _pinchTouch[0] = TouchLocation.Invalid;
+                                _pinchTouch[1] = TouchLocation.Invalid;
+                                break;
+                            }
+
+                            // If there are still other pressed locations then there
+                            // is nothing more we can do with this release.
+                            if (heldLocations != 0)
+                                break;
+
+                            // From testing XNA it seems we need a velocity 
+                            // of about 100 to classify this as a flick.
+                            var dist = Vector2.Distance(touch.Position, touch.PressPosition);
+                            if (dist > TapJitterTolerance &&
+                                    touch.Velocity.Length() > 100.0f &&
+                                    GestureIsEnabled(GestureType.Flick))
+                            {
+                                GestureList.Enqueue(new GestureSample(
+                                                        GestureType.Flick, touch.Timestamp,
+                                                        Vector2.Zero, Vector2.Zero,
+                                                        touch.Velocity, Vector2.Zero));
+
+                                //fall through, a drag should still happen even if a flick does
+                            }
+
+                            // If a drag is active then we need to finalize it.
+                            if (_dragGestureStarted != GestureType.None)
+                            {
+                                if (GestureIsEnabled(GestureType.DragComplete))
+                                    GestureList.Enqueue(new GestureSample(
+                                                            GestureType.DragComplete, touch.Timestamp,
+                                                            Vector2.Zero, Vector2.Zero,
+                                                            Vector2.Zero, Vector2.Zero));
+
+                                _dragGestureStarted = GestureType.None;
+                                break;
+                            }
+
+                            // If all else fails try to process it as a tap.
+                            ProcessTap(touch);
+                            break;
+                        }
+                }
+            }
+
+            // If the touch state hasn't changed then there is no 
+            // cleanup to do and no pinch to process.
+            if (!stateChanged)
+                return;
+
+            // If we have two pinch points then update the pinch state.
+            if (GestureIsEnabled(GestureType.Pinch) &&
+                    _pinchTouch[0].State != TouchLocationState.Invalid &&
+                    _pinchTouch[1].State != TouchLocationState.Invalid)
+                ProcessPinch(_pinchTouch);
+            else
+            {
+                // Make sure a partial pinch state 
+                // is not left hanging around.
+                _pinchGestureStarted = false;
+                _pinchTouch[0] = TouchLocation.Invalid;
+                _pinchTouch[1] = TouchLocation.Invalid;
+            }
+
+            // If all points are released then clear some states.
+            if (heldLocations == 0)
+            {
+                _tapDisabled = false;
+                _holdDisabled = false;
+                _dragGestureStarted = GestureType.None;
+            }
+        }
+
+        private void ProcessHold(TouchLocation touch)
+        {
+            if (!GestureIsEnabled(GestureType.Hold) || _holdDisabled)
+                return;
+
+            var elapsed = CurrentTimestamp - touch.PressTimestamp;
+            if (elapsed < TimeRequiredForHold)
+                return;
+
+            _holdDisabled = true;
+
+            GestureList.Enqueue(
+                new GestureSample(GestureType.Hold,
+                                    touch.Timestamp,
+                                    touch.Position, Vector2.Zero,
+                                    Vector2.Zero, Vector2.Zero));
+        }
+
+        private bool ProcessDoubleTap(TouchLocation touch)
+        {
+            if (!GestureIsEnabled(GestureType.DoubleTap) || _tapDisabled || _lastTap.State == TouchLocationState.Invalid)
+                return false;
+
+            // If the new tap is too far away from the last then
+            // this cannot be a double tap event.
+            var dist = Vector2.Distance(touch.Position, _lastTap.Position);
+            if (dist > TapJitterTolerance)
+                return false;
+
+            // Check that this tap happened within the standard 
+            // double tap time threshold of 300 milliseconds.
+            var elapsed = touch.Timestamp - _lastTap.Timestamp;
+            if (elapsed.TotalMilliseconds > 300)
+                return false;
+
+            GestureList.Enqueue(new GestureSample(
+                           GestureType.DoubleTap, touch.Timestamp,
+                           touch.Position, Vector2.Zero,
+                           Vector2.Zero, Vector2.Zero));
+
+            // Disable taps until after the next release.
+            _tapDisabled = true;
+
+            return true;
+        }
+
+        private TouchLocation _lastTap;
+
+        private void ProcessTap(TouchLocation touch)
+        {
+            if (_tapDisabled)
+                return;
+
+            // If the release is too far away from the press 
+            // position then this cannot be a tap event.
+            var dist = Vector2.Distance(touch.PressPosition, touch.Position);
+            if (dist > TapJitterTolerance)
+                return;
+
+            // If we pressed and held too long then don't 
+            // generate a tap event for it.
+            var elapsed = CurrentTimestamp - touch.PressTimestamp;
+            if (elapsed > TimeRequiredForHold)
+                return;
+
+            // Store the last tap for 
+            // double tap processing.
+            _lastTap = touch;
+
+            // Fire off the tap event immediately.
+            if (GestureIsEnabled(GestureType.Tap))
+            {
+                var tap = new GestureSample(
+                    GestureType.Tap, touch.Timestamp,
+                    touch.Position, Vector2.Zero,
+                    Vector2.Zero, Vector2.Zero);
+                GestureList.Enqueue(tap);
+            }
+        }
+
+        private GestureType _dragGestureStarted = GestureType.None;
+
+        private void ProcessDrag(TouchLocation touch)
+        {
+            var dragH = GestureIsEnabled(GestureType.HorizontalDrag);
+            var dragV = GestureIsEnabled(GestureType.VerticalDrag);
+            var dragF = GestureIsEnabled(GestureType.FreeDrag);
+
+            if (!dragH && !dragV && !dragF)
+                return;
+
+            // Make sure this is a move event and that we have
+            // a previous touch location.
+            TouchLocation prevTouch;
+            if (touch.State != TouchLocationState.Moved || !touch.TryGetPreviousLocation(out prevTouch))
+                return;
+
+            var delta = touch.Position - prevTouch.Position;
+
+            // If we're free dragging then stick to it.
+            if (_dragGestureStarted != GestureType.FreeDrag)
+            {
+                var isHorizontalDelta = Math.Abs(delta.X) > Math.Abs(delta.Y * 2.0f);
+                var isVerticalDelta = Math.Abs(delta.Y) > Math.Abs(delta.X * 2.0f);
+                var classify = _dragGestureStarted == GestureType.None;
+
+                // Once we enter either vertical or horizontal drags
+                // we stick to it... regardless of the delta.
+                if (dragH && ((classify && isHorizontalDelta) || _dragGestureStarted == GestureType.HorizontalDrag))
+                {
+                    delta.Y = 0;
+                    _dragGestureStarted = GestureType.HorizontalDrag;
+                }
+                else if (dragV && ((classify && isVerticalDelta) || _dragGestureStarted == GestureType.VerticalDrag))
+                {
+                    delta.X = 0;
+                    _dragGestureStarted = GestureType.VerticalDrag;
+                }
+
+                // If the delta isn't either horizontal or vertical
+                //then it could be a free drag if not classified.
+                else if (dragF && classify)
+                {
+                    _dragGestureStarted = GestureType.FreeDrag;
+                }
+                else
+                {
+                    // If we couldn't classify the drag then
+                    // it is nothing... set it to complete.
+                    _dragGestureStarted = GestureType.DragComplete;
+                }
+            }
+
+            // If the drag could not be classified then no gesture.
+            if (_dragGestureStarted == GestureType.None || _dragGestureStarted == GestureType.DragComplete)
+                return;
+
+            _tapDisabled = true;
+            _holdDisabled = true;
+
+            GestureList.Enqueue(new GestureSample(
+                                    _dragGestureStarted, touch.Timestamp,
+                                    touch.Position, Vector2.Zero,
+                                    delta, Vector2.Zero));
+        }
+
+        private void ProcessPinch(TouchLocation[] touches)
+        {
+            TouchLocation prevPos0;
+            TouchLocation prevPos1;
+
+            if (!touches[0].TryGetPreviousLocation(out prevPos0))
+                prevPos0 = touches[0];
+
+            if (!touches[1].TryGetPreviousLocation(out prevPos1))
+                prevPos1 = touches[1];
+
+            var delta0 = touches[0].Position - prevPos0.Position;
+            var delta1 = touches[1].Position - prevPos1.Position;
+
+            // Get the newest timestamp.
+            var timestamp = touches[0].Timestamp > touches[1].Timestamp ? touches[0].Timestamp : touches[1].Timestamp;
+
+            // If we were already in a drag state then fire
+            // off the drag completion event.
+            if (_dragGestureStarted != GestureType.None)
+            {
+                if (GestureIsEnabled(GestureType.DragComplete))
+                    GestureList.Enqueue(new GestureSample(
+                                            GestureType.DragComplete, timestamp,
+                                            Vector2.Zero, Vector2.Zero,
+                                            Vector2.Zero, Vector2.Zero));
+
+                _dragGestureStarted = GestureType.None;
+            }
+
+            GestureList.Enqueue(new GestureSample(
+                GestureType.Pinch,
+                timestamp,
+                touches[0].Position, touches[1].Position,
+                delta0, delta1));
+
+            _pinchGestureStarted = true;
+            _tapDisabled = true;
+            _holdDisabled = true;
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Input/Touch/TouchQueue.cs b/MonoGame.Framework/Input/Touch/TouchQueue.cs
new file mode 100644
index 00000000000..f2abfa74842
--- /dev/null
+++ b/MonoGame.Framework/Input/Touch/TouchQueue.cs
@@ -0,0 +1,42 @@
+using System.Collections.Concurrent;
+
+namespace Microsoft.Xna.Framework.Input.Touch
+{
+    /// <summary>
+    /// Stores touches to apply them once a frame for platforms that dispatch touches asynchronously
+    /// while user code is running.
+    /// </summary>
+    internal class TouchQueue
+    {
+        private readonly ConcurrentQueue<TouchEvent> _queue = new ConcurrentQueue<TouchEvent>();
+
+        public void Enqueue(int id, TouchLocationState state, Vector2 pos, bool isMouse = false)
+        {
+            _queue.Enqueue(new TouchEvent(id, state, pos, isMouse));
+        }
+
+        public void ProcessQueued()
+        {
+            TouchEvent ev;
+            while (_queue.TryDequeue(out ev))                
+                TouchPanel.AddEvent(ev.Id, ev.State, ev.Pos, ev.IsMouse);
+        }
+
+        private struct TouchEvent
+        {
+            public readonly int Id;
+            public readonly TouchLocationState State;
+            public readonly Vector2 Pos;
+            public readonly bool IsMouse;
+
+            public TouchEvent(int id, TouchLocationState state, Vector2 pos, bool isMouse)
+            {
+                Id = id;
+                State = state;
+                Pos = pos;
+                IsMouse = isMouse;
+            }
+        }
+
+    }
+}
diff --git a/MonoGame.Framework/LaunchParameters.cs b/MonoGame.Framework/LaunchParameters.cs
new file mode 100644
index 00000000000..edcb198697d
--- /dev/null
+++ b/MonoGame.Framework/LaunchParameters.cs
@@ -0,0 +1,12 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework
+{
+    public class LaunchParameters : Dictionary<string, string>
+    {
+    }
+}
diff --git a/MonoGame.Framework/MacOS/GamerServices/Guide.cs b/MonoGame.Framework/MacOS/GamerServices/Guide.cs
new file mode 100644
index 00000000000..b0d3caa59ad
--- /dev/null
+++ b/MonoGame.Framework/MacOS/GamerServices/Guide.cs
@@ -0,0 +1,272 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+#region Using clause
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Runtime.Remoting.Messaging;
+
+using Microsoft.Xna.Framework.Net;
+
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	public static class Guide
+	{
+		private static bool isScreenSaverEnabled;
+		private static bool isTrialMode;
+		internal static bool isVisible;
+		private static bool simulateTrialMode;
+		
+		internal static void Initialise(Game game) {
+			Guide.Window = game.Window;
+		}
+		delegate string ShowKeyboardInputDelegate (
+			PlayerIndex player, 
+			string title, 
+			string description, 
+			string defaultText, 
+			bool usePasswordMode);
+
+		public static string ShowKeyboardInput (
+			PlayerIndex player, 
+			string title, 
+			string description, 
+			string defaultText,
+			bool usePasswordMode)
+		{
+			string result = defaultText; 
+
+			return result;
+		}
+
+		public static IAsyncResult BeginShowKeyboardInput (
+			PlayerIndex player,
+			string title,
+			string description,
+			string defaultText,
+			AsyncCallback callback,
+			Object state)
+		{
+			return BeginShowKeyboardInput (player, title, description, defaultText, callback, state, false);
+		}
+
+		public static IAsyncResult BeginShowKeyboardInput (
+			PlayerIndex player,
+			string title,
+			string description,
+			string defaultText,
+			AsyncCallback callback,
+			Object state,
+			bool usePasswordMode)
+		{
+			isVisible = true;
+
+			ShowKeyboardInputDelegate ski = ShowKeyboardInput; 
+
+			return ski.BeginInvoke (player, title, description, defaultText, usePasswordMode, callback, ski);
+		}
+
+		public static string EndShowKeyboardInput (IAsyncResult result)
+		{
+			try {
+				ShowKeyboardInputDelegate ski = (ShowKeyboardInputDelegate)result.AsyncState; 
+
+				return ski.EndInvoke (result);
+			} finally {
+				isVisible = false;
+			}			
+		}
+
+		delegate Nullable<int> ShowMessageBoxDelegate (string title,
+			string text,
+			IEnumerable<string> buttons,
+			int focusButton,
+			MessageBoxIcon icon);
+
+		public static Nullable<int> ShowMessageBox (string title,
+				string text,
+				IEnumerable<string> buttons,
+				int focusButton,
+				MessageBoxIcon icon)
+		{
+			Nullable<int> result = null;
+
+			isVisible = true;			
+
+			return result;
+		}
+
+		public static IAsyncResult BeginShowMessageBox (
+				PlayerIndex player,
+				string title,
+				string text,
+				IEnumerable<string> buttons,
+				int focusButton,
+				MessageBoxIcon icon,
+				AsyncCallback callback,
+				Object state)
+		{	
+			isVisible = true;
+
+			ShowMessageBoxDelegate smb = ShowMessageBox; 
+
+			return smb.BeginInvoke (title, text, buttons, focusButton, icon, callback, smb);			
+		}
+
+		public static IAsyncResult BeginShowMessageBox (
+				string title,
+				string text,
+				IEnumerable<string> buttons,
+				int focusButton,
+				MessageBoxIcon icon,
+				AsyncCallback callback,
+				Object state)
+		{
+			return BeginShowMessageBox (PlayerIndex.One, title, text, buttons, focusButton, icon, callback, state);
+		}
+
+		public static Nullable<int> EndShowMessageBox (IAsyncResult result)
+		{
+			try {
+				ShowMessageBoxDelegate smbd = (ShowMessageBoxDelegate)result.AsyncState; 
+
+				return smbd.EndInvoke (result);
+			} finally {
+				isVisible = false;
+			}
+		}
+
+		public static void ShowMarketplace (PlayerIndex player)
+		{
+
+		}
+
+		public static void Show ()
+		{
+			/*GKPeerPickerController ppc = new GKPeerPickerController();
+			ppc.ConnectionTypesMask = GKPeerPickerConnectionType.Nearby;
+			ppc.Show();*/
+			ShowSignIn (1, false);
+		}
+
+		public static void ShowSignIn (int paneCount, bool onlineOnly)
+		{
+//			if (paneCount != 1) {
+//				new ArgumentException ("paneCount Can only be 1 on iPhone");
+//				return;
+//			}
+			if (isVisible)
+				return;
+			isVisible = true;
+			
+			MonoGameGamerServicesHelper.ShowSigninSheet();
+			
+			if (GamerServicesComponent.LocalNetworkGamer == null) {
+				GamerServicesComponent.LocalNetworkGamer = new LocalNetworkGamer ();
+			} else {
+				GamerServicesComponent.LocalNetworkGamer.SignedInGamer.BeginAuthentication (null, null);
+			}
+
+		}
+
+		public static void ShowLeaderboard ()
+		{
+			if ((Gamer.SignedInGamers.Count > 0) && (Gamer.SignedInGamers [0].IsSignedInToLive)) {	
+
+			}
+		}
+
+		public static void ShowAchievements ()
+		{
+			if ((Gamer.SignedInGamers.Count > 0) && (Gamer.SignedInGamers [0].IsSignedInToLive)) {
+
+			}
+		}
+
+		#region Properties
+		public static bool IsScreenSaverEnabled { 
+			get {
+				return isScreenSaverEnabled;
+			}
+			set {
+				isScreenSaverEnabled = value;
+			}
+		}
+
+		public static bool IsTrialMode { 
+			get {
+				return isTrialMode;
+			}
+			set {
+				isTrialMode = value;
+			}
+		}
+
+		public static bool IsVisible { 
+			get {
+				return isVisible;
+			}
+			set {
+				isVisible = value;
+			}
+		}
+
+		public static bool SimulateTrialMode { 
+			get {
+				return simulateTrialMode;
+			}
+			set {
+				simulateTrialMode = value;
+			}
+		}
+
+		[CLSCompliant(false)]
+		public static GameWindow Window { 
+			get;
+			set;
+		}
+		#endregion
+	}
+}
diff --git a/MonoGame.Framework/MacOS/GamerServices/MonoGameGamerServicesHelper.cs b/MonoGame.Framework/MacOS/GamerServices/MonoGameGamerServicesHelper.cs
new file mode 100644
index 00000000000..59da39cb96f
--- /dev/null
+++ b/MonoGame.Framework/MacOS/GamerServices/MonoGameGamerServicesHelper.cs
@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.Serialization.Formatters.Binary;
+using System.Drawing;
+
+using Foundation;
+using AppKit;
+using RectF = CoreGraphics.CGRect;
+using PointF = CoreGraphics.CGPoint;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	internal static class MonoGameGamerServicesHelper
+	{
+		internal static void ShowSigninSheet ()
+		{
+
+			NSApplication NSApp = NSApplication.SharedApplication;
+			NSWindow gameWindow = NSApp.MainWindow;
+
+			SigninController controller = new SigninController ();
+
+			NSWindow window = controller.Window;
+
+			// Something has happened with BeginSheet and needs to be looked into.
+			// Until then just use modal for now.
+			var frame = window.Frame;
+			var location = new PointF (gameWindow.Frame.Bottom, gameWindow.Frame.Left);
+			location = new PointF(gameWindow.Frame.Location.X, gameWindow.Frame.Location.Y);
+
+			window.SetFrameOrigin(location);
+			NSApp.BeginInvokeOnMainThread(delegate {
+				Guide.isVisible = true;
+//				NSApp.BeginSheet (window, gameWindow);
+				NSApp.RunModalForWindow (window);
+//				// sheet is up here.....
+//
+//				NSApp.EndSheet (window);
+				window.OrderOut (gameWindow);
+				Guide.isVisible = false;
+//
+			});
+			//window.MakeKeyAndOrderFront(gameWindow);
+//				SignedInGamer sig = new SignedInGamer();
+//				sig.DisplayName = "MonoMac Gamer";
+//				sig.Gamertag = "MonoMac Gamer";
+//				sig.InternalIdentifier = Guid.NewGuid();
+//
+//				Gamer.SignedInGamers.Add(sig);
+		}
+
+		internal static List<MonoGameLocalGamerProfile> DeserializeProfiles ()
+		{
+			var path = StorageLocation;
+			var fileName = Path.Combine(path, "LocalProfiles.dat");
+			var profiles  = new List<MonoGameLocalGamerProfile> ();
+			try {
+				using (Stream stream = File.Open (fileName, FileMode.Open)) {
+					BinaryFormatter bin = new BinaryFormatter ();
+
+					profiles = (List<MonoGameLocalGamerProfile>)bin.Deserialize (stream);
+				}
+				
+			} catch (IOException) {
+			}	
+			return profiles;
+		}
+
+		internal static void SerializeProfiles (List<MonoGameLocalGamerProfile> profiles)
+		{
+			var path = StorageLocation;
+			var fileName = Path.Combine(path, "LocalProfiles.dat");
+			try {
+				using (Stream stream = File.Open (fileName, FileMode.Create)) {
+					BinaryFormatter bin = new BinaryFormatter ();
+					bin.Serialize (stream, profiles);
+				}
+			} catch (IOException) {
+			}	
+		}
+		
+		internal static string StorageLocation 
+		{
+			get {
+				return Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
+			}	
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/MacOS/GamerServices/MonoGameLocalGamerProfile.cs b/MonoGame.Framework/MacOS/GamerServices/MonoGameLocalGamerProfile.cs
new file mode 100644
index 00000000000..e632a9127ef
--- /dev/null
+++ b/MonoGame.Framework/MacOS/GamerServices/MonoGameLocalGamerProfile.cs
@@ -0,0 +1,77 @@
+using System;
+using System.Globalization;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	[Serializable()]
+	internal class MonoGameLocalGamerProfile
+	{
+		Guid playerGuid;
+		
+		internal MonoGameLocalGamerProfile ()
+		{
+			playerGuid = Guid.NewGuid();
+		}
+
+		#region Properties
+		
+		internal Guid PlayerInternalIdentifier
+		{
+			get { return playerGuid; }
+			set { playerGuid = value; }
+		}
+		
+		internal string DisplayName {
+			get;
+			set;
+		}
+
+		internal string Gamertag {
+			get;
+			set;
+		}
+
+
+		internal byte[] GamerPicture {
+			get;
+			set;
+		}
+		
+		internal int GamerScore {
+			get;
+			set;
+		}
+
+		internal GamerZone GamerZone {
+			get;
+			set;
+		}
+
+		internal string Motto {
+			get;
+			set;
+		}
+
+		internal RegionInfo Region {
+			get;
+			set;
+		}
+
+		internal float Reputation {
+			get;
+			set;
+		}
+
+		internal int TitlesPlayed {
+			get;
+			set;
+		}
+
+		internal int TotalAchievements {
+			get;
+			set;
+		}		
+		#endregion
+	}
+}
+
diff --git a/MonoGame.Framework/MacOS/GamerServices/SignedInGamer.cs b/MonoGame.Framework/MacOS/GamerServices/SignedInGamer.cs
new file mode 100644
index 00000000000..91a7824cc26
--- /dev/null
+++ b/MonoGame.Framework/MacOS/GamerServices/SignedInGamer.cs
@@ -0,0 +1,313 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+#region Statement
+using System;
+
+using Foundation;
+using AppKit;
+
+#endregion Statement
+
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	public class SignedInGamer : Gamer
+	{	
+		private AchievementCollection gamerAchievements;
+		private FriendCollection friendCollection;
+		
+		internal Guid InternalIdentifier;
+		
+		delegate void AuthenticationDelegate ();
+
+		public IAsyncResult BeginAuthentication (AsyncCallback callback,Object asyncState)
+		{
+			// Go off authenticate
+			AuthenticationDelegate ad = DoAuthentication; 
+
+			return ad.BeginInvoke (callback, ad);
+		}
+
+		public void EndAuthentication (IAsyncResult result)
+		{
+			AuthenticationDelegate ad = (AuthenticationDelegate)result.AsyncState; 
+
+			ad.EndInvoke (result);
+		}
+
+		private void DoAuthentication ()
+		{
+			try {
+
+			} catch (Exception) {
+
+			}
+		}
+
+		public SignedInGamer ()
+		{
+
+			// Register to receive the GKPlayerAuthenticationDidChangeNotificationName so we are notified when 
+			// Authentication changes
+
+		}
+
+		private void AuthenticationCompletedCallback (IAsyncResult result)
+		{
+			EndAuthentication (result);	
+		}
+
+		#region Methods
+		public FriendCollection GetFriends ()
+		{
+			if (IsSignedInToLive) {
+				if (friendCollection == null) {
+					friendCollection = new FriendCollection ();
+				}
+			}
+
+			return friendCollection;
+		}
+
+		public bool IsFriend (Gamer gamer)
+		{
+			if (gamer == null) 
+				throw new ArgumentNullException ();
+
+			if (gamer.IsDisposed)
+				throw new ObjectDisposedException (gamer.ToString ());	
+
+			bool found = false;
+			foreach (FriendGamer f in friendCollection) {
+				if (f.Gamertag == gamer.Gamertag) {
+					found = true;
+				}
+			}
+			return found;
+
+		}
+
+		delegate AchievementCollection GetAchievementsDelegate ();
+
+		public IAsyncResult BeginGetAchievements (AsyncCallback callback, Object asyncState)
+		{
+			// Go off and grab achievements
+			GetAchievementsDelegate gad = GetAchievements; 
+
+			return gad.BeginInvoke (callback, gad);
+		}
+
+		private void GetAchievementCompletedCallback (IAsyncResult result)
+		{
+			// get the delegate that was used to call that method
+			GetAchievementsDelegate gad = (GetAchievementsDelegate)result.AsyncState; 
+
+			// get the return value from that method call
+			gamerAchievements = gad.EndInvoke (result);
+		}
+
+		public AchievementCollection EndGetAchievements (IAsyncResult result)
+		{
+			GetAchievementsDelegate gad = (GetAchievementsDelegate)result.AsyncState; 
+
+			gamerAchievements = gad.EndInvoke (result);
+
+			return gamerAchievements;
+		}
+
+		public AchievementCollection GetAchievements ()
+		{
+			if (IsSignedInToLive) {
+				if (gamerAchievements == null) {
+					gamerAchievements = new AchievementCollection ();
+				}
+			}
+			return gamerAchievements;
+		}
+
+		delegate void AwardAchievementDelegate (string achievementId, double percentageComplete);
+
+        public IAsyncResult BeginAwardAchievement(string achievementId, AsyncCallback callback, Object state)
+        {
+            return BeginAwardAchievement(achievementId, 100.0, callback, state);
+        }
+
+        public IAsyncResult BeginAwardAchievement(
+            string achievementId,
+            double percentageComplete,
+            AsyncCallback callback,
+            Object state
+        )
+		{	
+			// Go off and award the achievement
+			AwardAchievementDelegate aad = DoAwardAchievement; 
+
+			return aad.BeginInvoke (achievementId, percentageComplete, callback, aad);
+		}
+
+		public void EndAwardAchievement (IAsyncResult result)
+		{
+			AwardAchievementDelegate aad = (AwardAchievementDelegate)result.AsyncState; 
+
+			aad.EndInvoke (result);
+		}
+
+		private void AwardAchievementCompletedCallback (IAsyncResult result)
+		{
+			EndAwardAchievement (result);	
+		}
+
+		public void AwardAchievement (string achievementId)
+		{			
+			AwardAchievement (achievementId, 100.0f);
+		}
+
+		public void DoAwardAchievement (string achievementId, double percentageComplete)
+		{
+
+		}
+
+		public void AwardAchievement (string achievementId, double percentageComplete)
+		{
+			if (IsSignedInToLive) {
+				BeginAwardAchievement (achievementId, percentageComplete, AwardAchievementCompletedCallback, null);
+			}
+		}
+
+		public void UpdateScore (string aCategory, long aScore)
+		{
+			if (IsSignedInToLive) {
+
+			}
+		}
+
+		public void ResetAchievements ()
+		{
+			if (IsSignedInToLive) {
+
+			}
+		}
+
+		#endregion
+
+		#region Properties
+		public GameDefaults GameDefaults { 
+			get {
+				throw new NotSupportedException ();
+			}
+		}
+
+		public bool IsGuest { 
+			get {
+				throw new NotSupportedException ();
+			}
+		}
+
+		public bool IsSignedInToLive { 
+			get {				
+				return false;
+			}
+		}
+
+		public int PartySize { 
+			get {
+				throw new NotSupportedException ();
+			}
+			set {
+				throw new NotSupportedException ();
+			}
+		}
+
+		public PlayerIndex PlayerIndex {
+			get {
+				return PlayerIndex.One;
+			}
+		}
+
+		public GamerPresence Presence { 
+			get {
+				throw new NotSupportedException ();
+			}
+		}
+
+		GamerPrivileges _privileges = new GamerPrivileges ();
+
+		public GamerPrivileges Privileges {
+			get {
+				return _privileges;
+			}
+		}
+
+		#endregion
+
+
+		protected virtual void OnSignedIn (SignedInEventArgs e)
+		{
+            EventHelpers.Raise(this, SignedIn, e);
+        }
+
+		protected virtual void OnSignedOut (SignedOutEventArgs e)
+		{
+            EventHelpers.Raise(this, SignedOut, e);
+		}
+
+		#region Events
+		public static event EventHandler<SignedInEventArgs> SignedIn;
+		public static event EventHandler<SignedOutEventArgs> SignedOut;
+		#endregion
+	}
+
+	public class SignedInEventArgs : EventArgs
+	{
+		public SignedInEventArgs (SignedInGamer gamer)
+		{
+
+		}
+	}
+
+	public class SignedOutEventArgs : EventArgs
+	{
+		public SignedOutEventArgs (SignedInGamer gamer)
+		{
+
+		}
+	}
+}
diff --git a/MonoGame.Framework/MacOS/GamerServices/SigninController.cs b/MonoGame.Framework/MacOS/GamerServices/SigninController.cs
new file mode 100644
index 00000000000..1e55671cf71
--- /dev/null
+++ b/MonoGame.Framework/MacOS/GamerServices/SigninController.cs
@@ -0,0 +1,274 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using System.Drawing;
+
+using Foundation;
+using AppKit;
+using ObjCRuntime;
+using RectF = CoreGraphics.CGRect;
+using SizeF = CoreGraphics.CGSize;
+using PointF = CoreGraphics.CGPoint;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+	[CLSCompliant(false)]
+	public partial class SigninController : NSWindowController
+	{
+		
+		NSApplication NSApp = NSApplication.SharedApplication;	
+		
+		
+		internal List<MonoGameLocalGamerProfile> gamerList;
+		internal NSTableView tableView;
+		
+		#region Constructors
+
+		// Called when created from unmanaged code
+		public SigninController (IntPtr handle) : base(handle)
+		{
+			Initialize ();
+		}
+
+		// Called when created directly from a XIB file
+		[Export("initWithCoder:")]
+		public SigninController (NSCoder coder) : base(coder)
+		{
+			Initialize ();
+		}
+
+//		// Call to load from the XIB/NIB file
+//		public SigninController () : base("TableEdit")
+//		{
+//			Initialize ();
+//		}
+		
+		public SigninController()
+		{
+			Initialize();
+		}
+		
+		NSWindow window = null;
+		internal NSButton selectButton;
+		
+		// Shared initialization code
+		void Initialize ()
+		{
+			//window = new NSWindow(new RectangleF(0,0, 470, 250), NSWindowStyle.Titled | NSWindowStyle.Closable, NSBackingStore.Buffered, false);
+			window = new NSWindow(new RectF(0,0, 470, 250), NSWindowStyle.Titled, NSBackingStore.Buffered, false);
+			window.HasShadow = true;
+			NSView content = window.ContentView;
+			window.WindowController = this;
+			window.Title = "Sign In";
+            NSTextField signInLabel = new NSTextField(new RectF(17, 190, 109, 17));
+			signInLabel.StringValue = "Sign In:";
+			signInLabel.Editable = false;
+			signInLabel.Bordered = false;
+			signInLabel.BackgroundColor = NSColor.Control;
+			
+			content.AddSubview(signInLabel);
+			
+			// Create our select button
+            selectButton = new NSButton(new RectF(358,12,96,32));
+			selectButton.Title = "Select";
+			selectButton.SetButtonType(NSButtonType.MomentaryPushIn);
+			selectButton.BezelStyle = NSBezelStyle.Rounded;
+			
+			selectButton.Activated += delegate {
+				
+				profileSelected();
+			};
+			
+			selectButton.Enabled = false;
+			
+			content.AddSubview(selectButton);
+			
+			// Setup our table view
+            NSScrollView tableContainer = new NSScrollView(new RectF(20,60,428, 123));
+			tableContainer.BorderType = NSBorderType.BezelBorder;
+			tableContainer.AutohidesScrollers = true;
+			tableContainer.HasVerticalScroller = true;
+			
+            tableView = new NSTableView(new RectF(0,0,420, 123));
+			tableView.UsesAlternatingRowBackgroundColors = true;
+			
+			NSTableColumn colGamerTag = new NSTableColumn("Gamer");
+			tableView.AddColumn(colGamerTag);
+			
+			colGamerTag.Width = 420;
+			colGamerTag.HeaderCell.Title = "Gamer Profile";
+			tableContainer.DocumentView = tableView;
+			
+			content.AddSubview(tableContainer);
+			
+			// Create our add button
+            NSButton addButton = new NSButton(new RectF(20,27,25,25));
+			//Console.WriteLine(NSImage.AddTemplate);
+			addButton.Image = NSImage.ImageNamed("NSAddTemplate");
+			addButton.SetButtonType(NSButtonType.MomentaryPushIn);
+			addButton.BezelStyle = NSBezelStyle.SmallSquare;
+			
+			addButton.Activated += delegate {
+				addLocalPlayer();
+			};
+			content.AddSubview(addButton);
+			
+			// Create our remove button
+            NSButton removeButton = new NSButton(new RectF(44,27,25,25));
+			removeButton.Image = NSImage.ImageNamed("NSRemoveTemplate");
+			removeButton.SetButtonType(NSButtonType.MomentaryPushIn);
+			removeButton.BezelStyle = NSBezelStyle.SmallSquare;
+			
+			removeButton.Activated += delegate {
+				removeLocalPlayer();
+			};
+			content.AddSubview(removeButton);			
+			
+			gamerList = MonoGameGamerServicesHelper.DeserializeProfiles();
+			
+//			for (int x= 1; x< 25; x++) {
+//				gamerList.Add("Player " + x);
+//			}
+			tableView.DataSource = new GamersDataSource(this);
+			tableView.Delegate = new GamersTableDelegate(this);
+		}
+
+		#endregion
+		
+
+		public new NSWindow Window {
+			get { return window; }
+		}
+		
+		void profileSelected () 
+		{
+			if (tableView.SelectedRowCount > 0) {
+				var rowSelected = tableView.SelectedRow;
+				SignedInGamer sig = new SignedInGamer();
+                sig.DisplayName = gamerList[(int)rowSelected].DisplayName;
+                sig.Gamertag = gamerList[(int)rowSelected].Gamertag;
+                sig.InternalIdentifier = gamerList[(int)rowSelected].PlayerInternalIdentifier;
+				
+				Gamer.SignedInGamers.Add(sig);
+			}
+			MonoGameGamerServicesHelper.SerializeProfiles(gamerList);
+			NSApp.StopModal();
+		}
+		
+		void removeLocalPlayer () 
+		{
+			Console.WriteLine("Remove local");
+			var rowToRemove = tableView.SelectedRow;
+			if (rowToRemove < 0 || rowToRemove > gamerList.Count -1)
+				return;
+            gamerList.RemoveAt((int)rowToRemove);
+			tableView.ReloadData();
+		}
+		
+		void addLocalPlayer () 
+		{
+			MonoGameLocalGamerProfile prof = new MonoGameLocalGamerProfile();
+			prof.Gamertag = "New Player";
+			prof.DisplayName = prof.Gamertag;
+
+			gamerList.Add(prof);
+			
+			tableView.ReloadData();
+			int newPlayerRow = gamerList.Count - 1;
+			
+			tableView.ScrollRowToVisible(newPlayerRow);
+			tableView.EditColumn(0,newPlayerRow, new NSEvent(), true);
+			
+		}		
+	}
+
+	[CLSCompliant(false)]
+	public class GamersDataSource : NSTableViewDataSource
+	{
+		
+		SigninController controller;
+		
+		public GamersDataSource (SigninController controller) 
+		{
+			this.controller = controller;
+		}
+		
+#if MONOMAC
+		public override nint GetRowCount (NSTableView tableView)
+		{
+			return controller.gamerList.Count;
+		}
+		
+		public override NSObject GetObjectValue (NSTableView tableView, NSTableColumn tableColumn, nint row)
+		{
+            return new NSString(controller.gamerList[(int)row].Gamertag);
+		}
+		
+		public override void SetObjectValue (NSTableView tableView, NSObject theObject, NSTableColumn tableColumn, nint row)
+        {
+            var proposedValue = theObject.ToString();
+            if (proposedValue.Trim().Length > 0)
+            {
+                controller.gamerList[(int)row].Gamertag = theObject.ToString();
+                controller.gamerList[(int)row].DisplayName = theObject.ToString();
+            }
+        }
+#else
+        public override int GetRowCount (NSTableView tableView)
+        {
+            return controller.gamerList.Count;
+        }
+
+        public override NSObject GetObjectValue (NSTableView tableView, NSTableColumn tableColumn, int row)
+        {
+            return new NSString(controller.gamerList[row].Gamertag);
+        }
+
+        public override void SetObjectValue (NSTableView tableView, NSObject theObject, NSTableColumn tableColumn, int row)
+        {
+            var proposedValue = theObject.ToString();
+            if (proposedValue.Trim().Length > 0)
+            {
+                controller.gamerList[row].Gamertag = theObject.ToString();
+                controller.gamerList[row].DisplayName = theObject.ToString();
+            }
+        }
+#endif
+	}
+	
+	[CLSCompliant(false)]
+	public class GamersTableDelegate : NSTableViewDelegate
+	{
+		SigninController controller;
+		
+		public GamersTableDelegate (SigninController controller) 
+		{
+			this.controller = controller;
+		}
+
+#if MONOMAC
+		public override bool ShouldSelectRow (NSTableView tableView, nint row)
+#else
+        public override bool ShouldSelectRow (NSTableView tableView, int row)
+#endif
+		{
+            var profile = controller.gamerList[(int)row];
+			foreach (var gamer in Gamer.SignedInGamers) {
+				if (profile.PlayerInternalIdentifier == gamer.InternalIdentifier)
+					return false;
+			}
+			return true;
+		}
+		
+		public override void SelectionDidChange (NSNotification notification)
+		{
+			if (controller.tableView.SelectedRowCount > 0)
+				controller.selectButton.Enabled = true;
+			else
+				controller.selectButton.Enabled = false;
+		}
+		
+	}
+}
+
diff --git a/MonoGame.Framework/MathHelper.cs b/MonoGame.Framework/MathHelper.cs
new file mode 100644
index 00000000000..a9a26242601
--- /dev/null
+++ b/MonoGame.Framework/MathHelper.cs
@@ -0,0 +1,320 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Contains commonly used precalculated values and mathematical operations.
+    /// </summary>
+    public static class MathHelper
+    {
+    	/// <summary>
+        /// Represents the mathematical constant e(2.71828175).
+        /// </summary>
+        public const float E = (float)Math.E;
+        
+        /// <summary>
+        /// Represents the log base ten of e(0.4342945).
+        /// </summary>
+        public const float Log10E = 0.4342945f;
+        
+        /// <summary>
+        /// Represents the log base two of e(1.442695).
+        /// </summary>
+        public const float Log2E = 1.442695f;
+        
+        /// <summary>
+        /// Represents the value of pi(3.14159274).
+        /// </summary>
+        public const float Pi = (float)Math.PI;
+        
+        /// <summary>
+        /// Represents the value of pi divided by two(1.57079637).
+        /// </summary>
+        public const float PiOver2 = (float)(Math.PI / 2.0);
+        
+        /// <summary>
+        /// Represents the value of pi divided by four(0.7853982).
+        /// </summary>
+        public const float PiOver4 = (float)(Math.PI / 4.0);
+        
+        /// <summary>
+        /// Represents the value of pi times two(6.28318548).
+        /// </summary>
+        public const float TwoPi = (float)(Math.PI * 2.0);
+        
+        /// <summary>
+        /// Returns the Cartesian coordinate for one axis of a point that is defined by a given triangle and two normalized barycentric (areal) coordinates.
+        /// </summary>
+        /// <param name="value1">The coordinate on one axis of vertex 1 of the defining triangle.</param>
+        /// <param name="value2">The coordinate on the same axis of vertex 2 of the defining triangle.</param>
+        /// <param name="value3">The coordinate on the same axis of vertex 3 of the defining triangle.</param>
+        /// <param name="amount1">The normalized barycentric (areal) coordinate b2, equal to the weighting factor for vertex 2, the coordinate of which is specified in value2.</param>
+        /// <param name="amount2">The normalized barycentric (areal) coordinate b3, equal to the weighting factor for vertex 3, the coordinate of which is specified in value3.</param>
+        /// <returns>Cartesian coordinate of the specified point with respect to the axis being used.</returns>
+        public static float Barycentric(float value1, float value2, float value3, float amount1, float amount2)
+        {
+            return value1 + (value2 - value1) * amount1 + (value3 - value1) * amount2;
+        }
+
+	/// <summary>
+        /// Performs a Catmull-Rom interpolation using the specified positions.
+        /// </summary>
+        /// <param name="value1">The first position in the interpolation.</param>
+        /// <param name="value2">The second position in the interpolation.</param>
+        /// <param name="value3">The third position in the interpolation.</param>
+        /// <param name="value4">The fourth position in the interpolation.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <returns>A position that is the result of the Catmull-Rom interpolation.</returns>
+        public static float CatmullRom(float value1, float value2, float value3, float value4, float amount)
+        {
+            // Using formula from http://www.mvps.org/directx/articles/catmull/
+            // Internally using doubles not to lose precission
+            double amountSquared = amount * amount;
+            double amountCubed = amountSquared * amount;
+            return (float)(0.5 * (2.0 * value2 +
+                (value3 - value1) * amount +
+                (2.0 * value1 - 5.0 * value2 + 4.0 * value3 - value4) * amountSquared +
+                (3.0 * value2 - value1 - 3.0 * value3 + value4) * amountCubed));
+        }
+
+ 	/// <summary>
+        /// Restricts a value to be within a specified range.
+        /// </summary>
+        /// <param name="value">The value to clamp.</param>
+        /// <param name="min">The minimum value. If <c>value</c> is less than <c>min</c>, <c>min</c> will be returned.</param>
+        /// <param name="max">The maximum value. If <c>value</c> is greater than <c>max</c>, <c>max</c> will be returned.</param>
+        /// <returns>The clamped value.</returns>
+        public static float Clamp(float value, float min, float max)
+        {
+            // First we check to see if we're greater than the max
+            value = (value > max) ? max : value;
+
+            // Then we check to see if we're less than the min.
+            value = (value < min) ? min : value;
+
+            // There's no check to see if min > max.
+            return value;
+        }
+        
+        /// <summary>
+        /// Restricts a value to be within a specified range.
+        /// </summary>
+        /// <param name="value">The value to clamp.</param>
+        /// <param name="min">The minimum value. If <c>value</c> is less than <c>min</c>, <c>min</c> will be returned.</param>
+        /// <param name="max">The maximum value. If <c>value</c> is greater than <c>max</c>, <c>max</c> will be returned.</param>
+        /// <returns>The clamped value.</returns>
+        public static int Clamp(int value, int min, int max)
+        { 
+            value = (value > max) ? max : value; 
+            value = (value < min) ? min : value; 
+            return value;
+        }
+        
+        /// <summary>
+        /// Calculates the absolute value of the difference of two values.
+        /// </summary>
+        /// <param name="value1">Source value.</param>
+        /// <param name="value2">Source value.</param>
+        /// <returns>Distance between the two values.</returns>
+        public static float Distance(float value1, float value2)
+        {
+            return Math.Abs(value1 - value2);
+        }
+        
+        /// <summary>
+        /// Performs a Hermite spline interpolation.
+        /// </summary>
+        /// <param name="value1">Source position.</param>
+        /// <param name="tangent1">Source tangent.</param>
+        /// <param name="value2">Source position.</param>
+        /// <param name="tangent2">Source tangent.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <returns>The result of the Hermite spline interpolation.</returns>
+        public static float Hermite(float value1, float tangent1, float value2, float tangent2, float amount)
+        {
+            // All transformed to double not to lose precission
+            // Otherwise, for high numbers of param:amount the result is NaN instead of Infinity
+            double v1 = value1, v2 = value2, t1 = tangent1, t2 = tangent2, s = amount, result;
+            double sCubed = s * s * s;
+            double sSquared = s * s;
+
+            if (amount == 0f)
+                result = value1;
+            else if (amount == 1f)
+                result = value2;
+            else
+                result = (2 * v1 - 2 * v2 + t2 + t1) * sCubed +
+                    (3 * v2 - 3 * v1 - 2 * t1 - t2) * sSquared +
+                    t1 * s +
+                    v1;
+            return (float)result;
+        }
+        
+        
+        /// <summary>
+        /// Linearly interpolates between two values.
+        /// </summary>
+        /// <param name="value1">Source value.</param>
+        /// <param name="value2">Destination value.</param>
+        /// <param name="amount">Value between 0 and 1 indicating the weight of value2.</param>
+        /// <returns>Interpolated value.</returns> 
+        /// <remarks>This method performs the linear interpolation based on the following formula:
+        /// <code>value1 + (value2 - value1) * amount</code>.
+        /// Passing amount a value of 0 will cause value1 to be returned, a value of 1 will cause value2 to be returned.
+        /// See <see cref="MathHelper.LerpPrecise"/> for a less efficient version with more precision around edge cases.
+        /// </remarks>
+        public static float Lerp(float value1, float value2, float amount)
+        {
+            return value1 + (value2 - value1) * amount;
+        }
+
+
+        /// <summary>
+        /// Linearly interpolates between two values.
+        /// This method is a less efficient, more precise version of <see cref="MathHelper.Lerp"/>.
+        /// See remarks for more info.
+        /// </summary>
+        /// <param name="value1">Source value.</param>
+        /// <param name="value2">Destination value.</param>
+        /// <param name="amount">Value between 0 and 1 indicating the weight of value2.</param>
+        /// <returns>Interpolated value.</returns>
+        /// <remarks>This method performs the linear interpolation based on the following formula:
+        /// <code>((1 - amount) * value1) + (value2 * amount)</code>.
+        /// Passing amount a value of 0 will cause value1 to be returned, a value of 1 will cause value2 to be returned.
+        /// This method does not have the floating point precision issue that <see cref="MathHelper.Lerp"/> has.
+        /// i.e. If there is a big gap between value1 and value2 in magnitude (e.g. value1=10000000000000000, value2=1),
+        /// right at the edge of the interpolation range (amount=1), <see cref="MathHelper.Lerp"/> will return 0 (whereas it should return 1).
+        /// This also holds for value1=10^17, value2=10; value1=10^18,value2=10^2... so on.
+        /// For an in depth explanation of the issue, see below references:
+        /// Relevant Wikipedia Article: https://en.wikipedia.org/wiki/Linear_interpolation#Programming_language_support
+        /// Relevant StackOverflow Answer: http://stackoverflow.com/questions/4353525/floating-point-linear-interpolation#answer-23716956
+        /// </remarks>
+        public static float LerpPrecise(float value1, float value2, float amount)
+        {
+            return ((1 - amount) * value1) + (value2 * amount);
+        }
+
+        /// <summary>
+        /// Returns the greater of two values.
+        /// </summary>
+        /// <param name="value1">Source value.</param>
+        /// <param name="value2">Source value.</param>
+        /// <returns>The greater value.</returns>
+        public static float Max(float value1, float value2)
+        {
+            return value1 > value2 ? value1 : value2;
+        }
+
+        /// <summary>
+        /// Returns the greater of two values.
+        /// </summary>
+        /// <param name="value1">Source value.</param>
+        /// <param name="value2">Source value.</param>
+        /// <returns>The greater value.</returns>
+        public static int Max(int value1, int value2)
+        {
+            return value1 > value2 ? value1 : value2;
+        }
+        
+        /// <summary>
+        /// Returns the lesser of two values.
+        /// </summary>
+        /// <param name="value1">Source value.</param>
+        /// <param name="value2">Source value.</param>
+        /// <returns>The lesser value.</returns>
+        public static float Min(float value1, float value2)
+        {
+            return value1 < value2 ? value1 : value2;
+        }
+
+        /// <summary>
+        /// Returns the lesser of two values.
+        /// </summary>
+        /// <param name="value1">Source value.</param>
+        /// <param name="value2">Source value.</param>
+        /// <returns>The lesser value.</returns>
+        public static int Min(int value1, int value2)
+        {
+            return value1 < value2 ? value1 : value2;
+        }
+        
+        /// <summary>
+        /// Interpolates between two values using a cubic equation.
+        /// </summary>
+        /// <param name="value1">Source value.</param>
+        /// <param name="value2">Source value.</param>
+        /// <param name="amount">Weighting value.</param>
+        /// <returns>Interpolated value.</returns>
+        public static float SmoothStep(float value1, float value2, float amount)
+        {
+            // It is expected that 0 < amount < 1
+            // If amount < 0, return value1
+            // If amount > 1, return value2
+            float result = MathHelper.Clamp(amount, 0f, 1f);
+            result = MathHelper.Hermite(value1, 0f, value2, 0f, result);
+
+            return result;
+        }
+        
+        /// <summary>
+        /// Converts radians to degrees.
+        /// </summary>
+        /// <param name="radians">The angle in radians.</param>
+        /// <returns>The angle in degrees.</returns>
+        /// <remarks>
+        /// This method uses double precission internally,
+        /// though it returns single float
+        /// Factor = 180 / pi
+        /// </remarks>
+        public static float ToDegrees(float radians)
+        { 
+            return (float)(radians * 57.295779513082320876798154814105);
+        }
+        
+        /// <summary>
+        /// Converts degrees to radians.
+        /// </summary>
+        /// <param name="degrees">The angle in degrees.</param>
+        /// <returns>The angle in radians.</returns>
+        /// <remarks>
+        /// This method uses double precission internally,
+        /// though it returns single float
+        /// Factor = pi / 180
+        /// </remarks>
+        public static float ToRadians(float degrees)
+        { 
+            return (float)(degrees * 0.017453292519943295769236907684886);
+        }
+	 
+        /// <summary>
+        /// Reduces a given angle to a value between π and -π.
+        /// </summary>
+        /// <param name="angle">The angle to reduce, in radians.</param>
+        /// <returns>The new angle, in radians.</returns>
+        public static float WrapAngle(float angle)
+        {
+            if ((angle > -Pi) && (angle <= Pi))
+                return angle;
+            angle %= TwoPi;
+            if (angle <= -Pi)
+                return angle + TwoPi;
+            if (angle > Pi)
+                return angle - TwoPi;
+            return angle;
+        }
+
+ 	/// <summary>
+        /// Determines if value is powered by two.
+        /// </summary>
+        /// <param name="value">A value.</param>
+        /// <returns><c>true</c> if <c>value</c> is powered by two; otherwise <c>false</c>.</returns>
+	public static bool IsPowerOfTwo(int value)
+	{
+	     return (value > 0) && ((value & (value - 1)) == 0);
+	}
+    }
+}
diff --git a/MonoGame.Framework/Matrix.cs b/MonoGame.Framework/Matrix.cs
new file mode 100644
index 00000000000..42ac0d0dc1a
--- /dev/null
+++ b/MonoGame.Framework/Matrix.cs
@@ -0,0 +1,2474 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework
+{ 
+    /// <summary>
+    /// Represents the right-handed 4x4 floating point matrix, which can store translation, scale and rotation information.
+    /// </summary>
+    [DataContract]
+    [DebuggerDisplay("{DebugDisplayString,nq}")]
+    public struct Matrix : IEquatable<Matrix>
+    {
+        #region Public Constructors
+
+        /// <summary>
+        /// Constructs a matrix.
+        /// </summary>
+        /// <param name="m11">A first row and first column value.</param>
+        /// <param name="m12">A first row and second column value.</param>
+        /// <param name="m13">A first row and third column value.</param>
+        /// <param name="m14">A first row and fourth column value.</param>
+        /// <param name="m21">A second row and first column value.</param>
+        /// <param name="m22">A second row and second column value.</param>
+        /// <param name="m23">A second row and third column value.</param>
+        /// <param name="m24">A second row and fourth column value.</param>
+        /// <param name="m31">A third row and first column value.</param>
+        /// <param name="m32">A third row and second column value.</param>
+        /// <param name="m33">A third row and third column value.</param>
+        /// <param name="m34">A third row and fourth column value.</param>
+        /// <param name="m41">A fourth row and first column value.</param>
+        /// <param name="m42">A fourth row and second column value.</param>
+        /// <param name="m43">A fourth row and third column value.</param>
+        /// <param name="m44">A fourth row and fourth column value.</param>
+        public Matrix(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31,
+                      float m32, float m33, float m34, float m41, float m42, float m43, float m44)
+        {
+            this.M11 = m11;
+            this.M12 = m12;
+            this.M13 = m13;
+            this.M14 = m14;
+            this.M21 = m21;
+            this.M22 = m22;
+            this.M23 = m23;
+            this.M24 = m24;
+            this.M31 = m31;
+            this.M32 = m32;
+            this.M33 = m33;
+            this.M34 = m34;
+            this.M41 = m41;
+            this.M42 = m42;
+            this.M43 = m43;
+            this.M44 = m44;
+        }
+
+        /// <summary>
+        /// Constructs a matrix.
+        /// </summary>
+        /// <param name="row1">A first row of the created matrix.</param>
+        /// <param name="row2">A second row of the created matrix.</param>
+        /// <param name="row3">A third row of the created matrix.</param>
+        /// <param name="row4">A fourth row of the created matrix.</param>
+        public Matrix(Vector4 row1, Vector4 row2, Vector4 row3, Vector4 row4)
+        {
+            this.M11 = row1.X;
+            this.M12 = row1.Y;
+            this.M13 = row1.Z;
+            this.M14 = row1.W;
+            this.M21 = row2.X;
+            this.M22 = row2.Y;
+            this.M23 = row2.Z;
+            this.M24 = row2.W;
+            this.M31 = row3.X;
+            this.M32 = row3.Y;
+            this.M33 = row3.Z;
+            this.M34 = row3.W;
+            this.M41 = row4.X;
+            this.M42 = row4.Y;
+            this.M43 = row4.Z;
+            this.M44 = row4.W;
+        }
+
+        #endregion
+
+        #region Public Fields
+
+        /// <summary>
+        /// A first row and first column value.
+        /// </summary>
+        [DataMember]
+        public float M11;
+
+        /// <summary>
+        /// A first row and second column value.
+        /// </summary>
+        [DataMember]
+        public float M12;
+
+        /// <summary>
+        /// A first row and third column value.
+        /// </summary>
+        [DataMember]
+        public float M13;
+
+        /// <summary>
+        /// A first row and fourth column value.
+        /// </summary>
+        [DataMember]
+        public float M14;
+
+        /// <summary>
+        /// A second row and first column value.
+        /// </summary>
+        [DataMember]
+        public float M21;
+
+        /// <summary>
+        /// A second row and second column value.
+        /// </summary>
+        [DataMember]
+        public float M22;
+
+        /// <summary>
+        /// A second row and third column value.
+        /// </summary>
+        [DataMember]
+        public float M23;
+
+        /// <summary>
+        /// A second row and fourth column value.
+        /// </summary>
+        [DataMember]
+        public float M24;
+
+        /// <summary>
+        /// A third row and first column value.
+        /// </summary>
+        [DataMember]
+        public float M31;
+
+        /// <summary>
+        /// A third row and second column value.
+        /// </summary>
+        [DataMember]
+        public float M32;
+
+        /// <summary>
+        /// A third row and third column value.
+        /// </summary>
+        [DataMember]
+        public float M33;
+
+        /// <summary>
+        /// A third row and fourth column value.
+        /// </summary>
+        [DataMember]
+        public float M34;
+
+        /// <summary>
+        /// A fourth row and first column value.
+        /// </summary>
+        [DataMember]
+        public float M41;
+
+        /// <summary>
+        /// A fourth row and second column value.
+        /// </summary>
+        [DataMember]
+        public float M42;
+
+        /// <summary>
+        /// A fourth row and third column value.
+        /// </summary>
+        [DataMember]
+        public float M43;
+
+        /// <summary>
+        /// A fourth row and fourth column value.
+        /// </summary>
+        [DataMember]
+        public float M44;
+
+        #endregion
+
+        #region Indexers
+
+        public float this[int index]
+        {
+            get
+            {
+                switch (index)
+                {
+                    case 0: return M11;
+                    case 1: return M12;
+                    case 2: return M13;
+                    case 3: return M14;
+                    case 4: return M21;
+                    case 5: return M22;
+                    case 6: return M23;
+                    case 7: return M24;
+                    case 8: return M31;
+                    case 9: return M32;
+                    case 10: return M33;
+                    case 11: return M34;
+                    case 12: return M41;
+                    case 13: return M42;
+                    case 14: return M43;
+                    case 15: return M44;
+                }
+                throw new ArgumentOutOfRangeException();
+            }
+
+            set
+            {
+                switch (index)
+                {
+                    case 0: M11 = value; break;
+                    case 1: M12 = value; break;
+                    case 2: M13 = value; break;
+                    case 3: M14 = value; break;
+                    case 4: M21 = value; break;
+                    case 5: M22 = value; break;
+                    case 6: M23 = value; break;
+                    case 7: M24 = value; break;
+                    case 8: M31 = value; break;
+                    case 9: M32 = value; break;
+                    case 10: M33 = value; break;
+                    case 11: M34 = value; break;
+                    case 12: M41 = value; break;
+                    case 13: M42 = value; break;
+                    case 14: M43 = value; break;
+                    case 15: M44 = value; break;
+                    default: throw new ArgumentOutOfRangeException();
+                }
+            }
+        }
+
+        public float this[int row, int column]
+        {
+            get
+            {
+                return this[(row * 4) + column];
+            }
+
+            set
+            {
+                this[(row * 4) + column] = value;
+            }
+        }
+
+        #endregion
+
+        #region Private Members
+        private static Matrix identity = new Matrix(1f, 0f, 0f, 0f, 
+		                                            0f, 1f, 0f, 0f, 
+		                                            0f, 0f, 1f, 0f, 
+		                                            0f, 0f, 0f, 1f);
+        #endregion
+
+        #region Public Properties
+
+        /// <summary>
+        /// The backward vector formed from the third row M31, M32, M33 elements.
+        /// </summary>
+        public Vector3 Backward
+        {
+            get
+            {
+                return new Vector3(this.M31, this.M32, this.M33);
+            }
+            set
+            {
+                this.M31 = value.X;
+                this.M32 = value.Y;
+                this.M33 = value.Z;
+            }
+        }
+
+        /// <summary>
+        /// The down vector formed from the second row -M21, -M22, -M23 elements.
+        /// </summary>
+        public Vector3 Down
+        {
+            get
+            {
+                return new Vector3(-this.M21, -this.M22, -this.M23);
+            }
+            set
+            {
+                this.M21 = -value.X;
+                this.M22 = -value.Y;
+                this.M23 = -value.Z;
+            }
+        }
+
+        /// <summary>
+        /// The forward vector formed from the third row -M31, -M32, -M33 elements.
+        /// </summary>
+        public Vector3 Forward
+        {
+            get
+            {
+                return new Vector3(-this.M31, -this.M32, -this.M33);
+            }
+            set
+            {
+                this.M31 = -value.X;
+                this.M32 = -value.Y;
+                this.M33 = -value.Z;
+            }
+        }
+
+        /// <summary>
+        /// Returns the identity matrix.
+        /// </summary>
+        public static Matrix Identity
+        {
+            get { return identity; }
+        }
+
+        /// <summary>
+        /// The left vector formed from the first row -M11, -M12, -M13 elements.
+        /// </summary>
+        public Vector3 Left
+        {
+            get
+            {
+                return new Vector3(-this.M11, -this.M12, -this.M13);
+            }
+            set
+            {
+                this.M11 = -value.X;
+                this.M12 = -value.Y;
+                this.M13 = -value.Z;
+            }
+        }
+
+        /// <summary>
+        /// The right vector formed from the first row M11, M12, M13 elements.
+        /// </summary>
+        public Vector3 Right
+        {
+            get
+            {
+                return new Vector3(this.M11, this.M12, this.M13);
+            }
+            set
+            {
+                this.M11 = value.X;
+                this.M12 = value.Y;
+                this.M13 = value.Z;
+            }
+        }
+
+        /// <summary>
+        /// Position stored in this matrix.
+        /// </summary>
+        public Vector3 Translation
+        {
+            get
+            {
+                return new Vector3(this.M41, this.M42, this.M43);
+            }
+            set
+            {
+                this.M41 = value.X;
+                this.M42 = value.Y;
+                this.M43 = value.Z;
+            }
+        }
+
+        /// <summary>
+        /// The upper vector formed from the second row M21, M22, M23 elements.
+        /// </summary>
+        public Vector3 Up
+        {
+            get
+            {
+                return new Vector3(this.M21, this.M22, this.M23);
+            }
+            set
+            {
+                this.M21 = value.X;
+                this.M22 = value.Y;
+                this.M23 = value.Z;
+            }
+        }
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> which contains sum of two matrixes.
+        /// </summary>
+        /// <param name="matrix1">The first matrix to add.</param>
+        /// <param name="matrix2">The second matrix to add.</param>
+        /// <returns>The result of the matrix addition.</returns>
+        public static Matrix Add(Matrix matrix1, Matrix matrix2)
+        {
+            matrix1.M11 += matrix2.M11;
+            matrix1.M12 += matrix2.M12;
+            matrix1.M13 += matrix2.M13;
+            matrix1.M14 += matrix2.M14;
+            matrix1.M21 += matrix2.M21;
+            matrix1.M22 += matrix2.M22;
+            matrix1.M23 += matrix2.M23;
+            matrix1.M24 += matrix2.M24;
+            matrix1.M31 += matrix2.M31;
+            matrix1.M32 += matrix2.M32;
+            matrix1.M33 += matrix2.M33;
+            matrix1.M34 += matrix2.M34;
+            matrix1.M41 += matrix2.M41;
+            matrix1.M42 += matrix2.M42;
+            matrix1.M43 += matrix2.M43;
+            matrix1.M44 += matrix2.M44;
+            return matrix1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> which contains sum of two matrixes.
+        /// </summary>
+        /// <param name="matrix1">The first matrix to add.</param>
+        /// <param name="matrix2">The second matrix to add.</param>
+        /// <param name="result">The result of the matrix addition as an output parameter.</param>
+        public static void Add(ref Matrix matrix1, ref Matrix matrix2, out Matrix result)
+        {
+            result.M11 = matrix1.M11 + matrix2.M11;
+            result.M12 = matrix1.M12 + matrix2.M12;
+            result.M13 = matrix1.M13 + matrix2.M13;
+            result.M14 = matrix1.M14 + matrix2.M14;
+            result.M21 = matrix1.M21 + matrix2.M21;
+            result.M22 = matrix1.M22 + matrix2.M22;
+            result.M23 = matrix1.M23 + matrix2.M23;
+            result.M24 = matrix1.M24 + matrix2.M24;
+            result.M31 = matrix1.M31 + matrix2.M31;
+            result.M32 = matrix1.M32 + matrix2.M32;
+            result.M33 = matrix1.M33 + matrix2.M33;
+            result.M34 = matrix1.M34 + matrix2.M34;
+            result.M41 = matrix1.M41 + matrix2.M41;
+            result.M42 = matrix1.M42 + matrix2.M42;
+            result.M43 = matrix1.M43 + matrix2.M43;
+            result.M44 = matrix1.M44 + matrix2.M44;
+
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> for spherical billboarding that rotates around specified object position.
+        /// </summary>
+        /// <param name="objectPosition">Position of billboard object. It will rotate around that vector.</param>
+        /// <param name="cameraPosition">The camera position.</param>
+        /// <param name="cameraUpVector">The camera up vector.</param>
+        /// <param name="cameraForwardVector">Optional camera forward vector.</param>
+        /// <returns>The <see cref="Matrix"/> for spherical billboarding.</returns>
+        public static Matrix CreateBillboard(Vector3 objectPosition, Vector3 cameraPosition,
+            Vector3 cameraUpVector, Nullable<Vector3> cameraForwardVector)
+        {
+            Matrix result;
+
+            // Delegate to the other overload of the function to do the work
+            CreateBillboard(ref objectPosition, ref cameraPosition, ref cameraUpVector, cameraForwardVector, out result);
+
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> for spherical billboarding that rotates around specified object position.
+        /// </summary>
+        /// <param name="objectPosition">Position of billboard object. It will rotate around that vector.</param>
+        /// <param name="cameraPosition">The camera position.</param>
+        /// <param name="cameraUpVector">The camera up vector.</param>
+        /// <param name="cameraForwardVector">Optional camera forward vector.</param>
+        /// <param name="result">The <see cref="Matrix"/> for spherical billboarding as an output parameter.</param>
+        public static void CreateBillboard(ref Vector3 objectPosition, ref Vector3 cameraPosition,
+            ref Vector3 cameraUpVector, Vector3? cameraForwardVector, out Matrix result)
+        {
+            Vector3 vector;
+            Vector3 vector2;
+            Vector3 vector3;
+            vector.X = objectPosition.X - cameraPosition.X;
+            vector.Y = objectPosition.Y - cameraPosition.Y;
+            vector.Z = objectPosition.Z - cameraPosition.Z;
+            float num = vector.LengthSquared();
+            if (num < 0.0001f)
+            {
+                vector = cameraForwardVector.HasValue ? -cameraForwardVector.Value : Vector3.Forward;
+            }
+            else
+            {
+                Vector3.Multiply(ref vector, (float)(1f / ((float)Math.Sqrt((double)num))), out vector);
+            }
+            Vector3.Cross(ref cameraUpVector, ref vector, out vector3);
+            vector3.Normalize();
+            Vector3.Cross(ref vector, ref vector3, out vector2);
+            result.M11 = vector3.X;
+            result.M12 = vector3.Y;
+            result.M13 = vector3.Z;
+            result.M14 = 0;
+            result.M21 = vector2.X;
+            result.M22 = vector2.Y;
+            result.M23 = vector2.Z;
+            result.M24 = 0;
+            result.M31 = vector.X;
+            result.M32 = vector.Y;
+            result.M33 = vector.Z;
+            result.M34 = 0;
+            result.M41 = objectPosition.X;
+            result.M42 = objectPosition.Y;
+            result.M43 = objectPosition.Z;
+            result.M44 = 1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> for cylindrical billboarding that rotates around specified axis.
+        /// </summary>
+        /// <param name="objectPosition">Object position the billboard will rotate around.</param>
+        /// <param name="cameraPosition">Camera position.</param>
+        /// <param name="rotateAxis">Axis of billboard for rotation.</param>
+        /// <param name="cameraForwardVector">Optional camera forward vector.</param>
+        /// <param name="objectForwardVector">Optional object forward vector.</param>
+        /// <returns>The <see cref="Matrix"/> for cylindrical billboarding.</returns>
+        public static Matrix CreateConstrainedBillboard(Vector3 objectPosition, Vector3 cameraPosition,
+            Vector3 rotateAxis, Nullable<Vector3> cameraForwardVector, Nullable<Vector3> objectForwardVector)
+        {
+            Matrix result;
+            CreateConstrainedBillboard(ref objectPosition, ref cameraPosition, ref rotateAxis,
+                cameraForwardVector, objectForwardVector, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> for cylindrical billboarding that rotates around specified axis.
+        /// </summary>
+        /// <param name="objectPosition">Object position the billboard will rotate around.</param>
+        /// <param name="cameraPosition">Camera position.</param>
+        /// <param name="rotateAxis">Axis of billboard for rotation.</param>
+        /// <param name="cameraForwardVector">Optional camera forward vector.</param>
+        /// <param name="objectForwardVector">Optional object forward vector.</param>
+        /// <param name="result">The <see cref="Matrix"/> for cylindrical billboarding as an output parameter.</param>
+        public static void CreateConstrainedBillboard(ref Vector3 objectPosition, ref Vector3 cameraPosition,
+            ref Vector3 rotateAxis, Vector3? cameraForwardVector, Vector3? objectForwardVector, out Matrix result)
+        {
+            float num;
+		    Vector3 vector;
+		    Vector3 vector2;
+		    Vector3 vector3;
+		    vector2.X = objectPosition.X - cameraPosition.X;
+		    vector2.Y = objectPosition.Y - cameraPosition.Y;
+		    vector2.Z = objectPosition.Z - cameraPosition.Z;
+		    float num2 = vector2.LengthSquared();
+		    if (num2 < 0.0001f)
+		    {
+		        vector2 = cameraForwardVector.HasValue ? -cameraForwardVector.Value : Vector3.Forward;
+		    }
+		    else
+		    {
+		        Vector3.Multiply(ref vector2, (float) (1f / ((float) Math.Sqrt((double) num2))), out vector2);
+		    }
+		    Vector3 vector4 = rotateAxis;
+		    Vector3.Dot(ref rotateAxis, ref vector2, out num);
+		    if (Math.Abs(num) > 0.9982547f)
+		    {
+		        if (objectForwardVector.HasValue)
+		        {
+		            vector = objectForwardVector.Value;
+		            Vector3.Dot(ref rotateAxis, ref vector, out num);
+		            if (Math.Abs(num) > 0.9982547f)
+		            {
+		                num = ((rotateAxis.X * Vector3.Forward.X) + (rotateAxis.Y * Vector3.Forward.Y)) + (rotateAxis.Z * Vector3.Forward.Z);
+		                vector = (Math.Abs(num) > 0.9982547f) ? Vector3.Right : Vector3.Forward;
+		            }
+		        }
+		        else
+		        {
+		            num = ((rotateAxis.X * Vector3.Forward.X) + (rotateAxis.Y * Vector3.Forward.Y)) + (rotateAxis.Z * Vector3.Forward.Z);
+		            vector = (Math.Abs(num) > 0.9982547f) ? Vector3.Right : Vector3.Forward;
+		        }
+		        Vector3.Cross(ref rotateAxis, ref vector, out vector3);
+		        vector3.Normalize();
+		        Vector3.Cross(ref vector3, ref rotateAxis, out vector);
+		        vector.Normalize();
+		    }
+		    else
+		    {
+		        Vector3.Cross(ref rotateAxis, ref vector2, out vector3);
+		        vector3.Normalize();
+		        Vector3.Cross(ref vector3, ref vector4, out vector);
+		        vector.Normalize();
+		    }
+		    result.M11 = vector3.X;
+		    result.M12 = vector3.Y;
+		    result.M13 = vector3.Z;
+		    result.M14 = 0;
+		    result.M21 = vector4.X;
+		    result.M22 = vector4.Y;
+		    result.M23 = vector4.Z;
+		    result.M24 = 0;
+		    result.M31 = vector.X;
+		    result.M32 = vector.Y;
+		    result.M33 = vector.Z;
+		    result.M34 = 0;
+		    result.M41 = objectPosition.X;
+		    result.M42 = objectPosition.Y;
+		    result.M43 = objectPosition.Z;
+		    result.M44 = 1;
+
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> which contains the rotation moment around specified axis.
+        /// </summary>
+        /// <param name="axis">The axis of rotation.</param>
+        /// <param name="angle">The angle of rotation in radians.</param>
+        /// <returns>The rotation <see cref="Matrix"/>.</returns>
+        public static Matrix CreateFromAxisAngle(Vector3 axis, float angle)
+        {
+            Matrix result;
+            CreateFromAxisAngle(ref axis, angle, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> which contains the rotation moment around specified axis.
+        /// </summary>
+        /// <param name="axis">The axis of rotation.</param>
+        /// <param name="angle">The angle of rotation in radians.</param>
+        /// <param name="result">The rotation <see cref="Matrix"/> as an output parameter.</param>
+        public static void CreateFromAxisAngle(ref Vector3 axis, float angle, out Matrix result)
+        {
+            float x = axis.X;
+		    float y = axis.Y;
+		    float z = axis.Z;
+		    float num2 = (float) Math.Sin((double) angle);
+		    float num = (float) Math.Cos((double) angle);
+		    float num11 = x * x;
+		    float num10 = y * y;
+		    float num9 = z * z;
+		    float num8 = x * y;
+		    float num7 = x * z;
+		    float num6 = y * z;
+		    result.M11 = num11 + (num * (1f - num11));
+		    result.M12 = (num8 - (num * num8)) + (num2 * z);
+		    result.M13 = (num7 - (num * num7)) - (num2 * y);
+		    result.M14 = 0;
+		    result.M21 = (num8 - (num * num8)) - (num2 * z);
+		    result.M22 = num10 + (num * (1f - num10));
+		    result.M23 = (num6 - (num * num6)) + (num2 * x);
+		    result.M24 = 0;
+		    result.M31 = (num7 - (num * num7)) + (num2 * y);
+		    result.M32 = (num6 - (num * num6)) - (num2 * x);
+		    result.M33 = num9 + (num * (1f - num9));
+		    result.M34 = 0;
+		    result.M41 = 0;
+		    result.M42 = 0;
+		    result.M43 = 0;
+		    result.M44 = 1;
+        }
+
+        /// <summary>
+        /// Creates a new rotation <see cref="Matrix"/> from a <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="quaternion"><see cref="Quaternion"/> of rotation moment.</param>
+        /// <returns>The rotation <see cref="Matrix"/>.</returns>
+        public static Matrix CreateFromQuaternion(Quaternion quaternion)
+        {
+            Matrix result;
+            CreateFromQuaternion(ref quaternion, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new rotation <see cref="Matrix"/> from a <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="quaternion"><see cref="Quaternion"/> of rotation moment.</param>
+        /// <param name="result">The rotation <see cref="Matrix"/> as an output parameter.</param>
+        public static void CreateFromQuaternion(ref Quaternion quaternion, out Matrix result)
+        {
+            float num9 = quaternion.X * quaternion.X;
+		    float num8 = quaternion.Y * quaternion.Y;
+		    float num7 = quaternion.Z * quaternion.Z;
+		    float num6 = quaternion.X * quaternion.Y;
+		    float num5 = quaternion.Z * quaternion.W;
+		    float num4 = quaternion.Z * quaternion.X;
+		    float num3 = quaternion.Y * quaternion.W;
+		    float num2 = quaternion.Y * quaternion.Z;
+		    float num = quaternion.X * quaternion.W;
+		    result.M11 = 1f - (2f * (num8 + num7));
+		    result.M12 = 2f * (num6 + num5);
+		    result.M13 = 2f * (num4 - num3);
+		    result.M14 = 0f;
+		    result.M21 = 2f * (num6 - num5);
+		    result.M22 = 1f - (2f * (num7 + num9));
+		    result.M23 = 2f * (num2 + num);
+		    result.M24 = 0f;
+		    result.M31 = 2f * (num4 + num3);
+		    result.M32 = 2f * (num2 - num);
+		    result.M33 = 1f - (2f * (num8 + num9));
+		    result.M34 = 0f;
+		    result.M41 = 0f;
+		    result.M42 = 0f;
+		    result.M43 = 0f;
+		    result.M44 = 1f;
+        }
+
+        /// <summary>
+        /// Creates a new rotation <see cref="Matrix"/> from the specified yaw, pitch and roll values.
+        /// </summary>
+        /// <param name="yaw">The yaw rotation value in radians.</param>
+        /// <param name="pitch">The pitch rotation value in radians.</param>
+        /// <param name="roll">The roll rotation value in radians.</param>
+        /// <returns>The rotation <see cref="Matrix"/>.</returns>
+        /// <remarks>For more information about yaw, pitch and roll visit http://en.wikipedia.org/wiki/Euler_angles.
+        /// </remarks>
+		public static Matrix CreateFromYawPitchRoll(float yaw, float pitch, float roll)
+		{
+			Matrix matrix;
+            CreateFromYawPitchRoll(yaw, pitch, roll, out matrix);
+		    return matrix;
+		}
+
+        /// <summary>
+        /// Creates a new rotation <see cref="Matrix"/> from the specified yaw, pitch and roll values.
+        /// </summary>
+        /// <param name="yaw">The yaw rotation value in radians.</param>
+        /// <param name="pitch">The pitch rotation value in radians.</param>
+        /// <param name="roll">The roll rotation value in radians.</param>
+        /// <param name="result">The rotation <see cref="Matrix"/> as an output parameter.</param>
+        /// <remarks>For more information about yaw, pitch and roll visit http://en.wikipedia.org/wiki/Euler_angles.
+        /// </remarks>
+		public static void CreateFromYawPitchRoll(float yaw, float pitch, float roll, out Matrix result)
+		{
+			Quaternion quaternion;
+		    Quaternion.CreateFromYawPitchRoll(yaw, pitch, roll, out quaternion);
+		    CreateFromQuaternion(ref quaternion, out result);
+		}
+
+        /// <summary>
+        /// Creates a new viewing <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="cameraPosition">Position of the camera.</param>
+        /// <param name="cameraTarget">Lookup vector of the camera.</param>
+        /// <param name="cameraUpVector">The direction of the upper edge of the camera.</param>
+        /// <returns>The viewing <see cref="Matrix"/>.</returns>
+        public static Matrix CreateLookAt(Vector3 cameraPosition, Vector3 cameraTarget, Vector3 cameraUpVector)
+        {
+            Matrix matrix;
+            CreateLookAt(ref cameraPosition, ref cameraTarget, ref cameraUpVector, out matrix);
+            return matrix;
+        }
+
+        /// <summary>
+        /// Creates a new viewing <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="cameraPosition">Position of the camera.</param>
+        /// <param name="cameraTarget">Lookup vector of the camera.</param>
+        /// <param name="cameraUpVector">The direction of the upper edge of the camera.</param>
+        /// <param name="result">The viewing <see cref="Matrix"/> as an output parameter.</param>
+        public static void CreateLookAt(ref Vector3 cameraPosition, ref Vector3 cameraTarget, ref Vector3 cameraUpVector, out Matrix result)
+        {
+            var vector = Vector3.Normalize(cameraPosition - cameraTarget);
+            var vector2 = Vector3.Normalize(Vector3.Cross(cameraUpVector, vector));
+            var vector3 = Vector3.Cross(vector, vector2);
+		    result.M11 = vector2.X;
+		    result.M12 = vector3.X;
+		    result.M13 = vector.X;
+		    result.M14 = 0f;
+		    result.M21 = vector2.Y;
+		    result.M22 = vector3.Y;
+		    result.M23 = vector.Y;
+		    result.M24 = 0f;
+		    result.M31 = vector2.Z;
+		    result.M32 = vector3.Z;
+		    result.M33 = vector.Z;
+		    result.M34 = 0f;
+		    result.M41 = -Vector3.Dot(vector2, cameraPosition);
+		    result.M42 = -Vector3.Dot(vector3, cameraPosition);
+		    result.M43 = -Vector3.Dot(vector, cameraPosition);
+		    result.M44 = 1f;
+        }
+
+        /// <summary>
+        /// Creates a new projection <see cref="Matrix"/> for orthographic view.
+        /// </summary>
+        /// <param name="width">Width of the viewing volume.</param>
+        /// <param name="height">Height of the viewing volume.</param>
+        /// <param name="zNearPlane">Depth of the near plane.</param>
+        /// <param name="zFarPlane">Depth of the far plane.</param>
+        /// <returns>The new projection <see cref="Matrix"/> for orthographic view.</returns>
+        public static Matrix CreateOrthographic(float width, float height, float zNearPlane, float zFarPlane)
+        {
+            Matrix matrix;
+            CreateOrthographic(width, height, zNearPlane, zFarPlane, out matrix);
+		    return matrix;
+        }
+
+        /// <summary>
+        /// Creates a new projection <see cref="Matrix"/> for orthographic view.
+        /// </summary>
+        /// <param name="width">Width of the viewing volume.</param>
+        /// <param name="height">Height of the viewing volume.</param>
+        /// <param name="zNearPlane">Depth of the near plane.</param>
+        /// <param name="zFarPlane">Depth of the far plane.</param>
+        /// <param name="result">The new projection <see cref="Matrix"/> for orthographic view as an output parameter.</param>
+        public static void CreateOrthographic(float width, float height, float zNearPlane, float zFarPlane, out Matrix result)
+        {
+            result.M11 = 2f / width;
+		    result.M12 = result.M13 = result.M14 = 0f;
+		    result.M22 = 2f / height;
+		    result.M21 = result.M23 = result.M24 = 0f;
+		    result.M33 = 1f / (zNearPlane - zFarPlane);
+		    result.M31 = result.M32 = result.M34 = 0f;
+		    result.M41 = result.M42 = 0f;
+		    result.M43 = zNearPlane / (zNearPlane - zFarPlane);
+		    result.M44 = 1f;
+        }
+
+        /// <summary>
+        /// Creates a new projection <see cref="Matrix"/> for customized orthographic view.
+        /// </summary>
+        /// <param name="left">Lower x-value at the near plane.</param>
+        /// <param name="right">Upper x-value at the near plane.</param>
+        /// <param name="bottom">Lower y-coordinate at the near plane.</param>
+        /// <param name="top">Upper y-value at the near plane.</param>
+        /// <param name="zNearPlane">Depth of the near plane.</param>
+        /// <param name="zFarPlane">Depth of the far plane.</param>
+        /// <returns>The new projection <see cref="Matrix"/> for customized orthographic view.</returns>
+        public static Matrix CreateOrthographicOffCenter(float left, float right, float bottom, float top, float zNearPlane, float zFarPlane)
+        {
+			Matrix matrix;
+            CreateOrthographicOffCenter(left, right, bottom, top, zNearPlane, zFarPlane, out matrix);
+			return matrix;
+        }
+
+        /// <summary>
+        /// Creates a new projection <see cref="Matrix"/> for customized orthographic view.
+        /// </summary>
+        /// <param name="viewingVolume">The viewing volume.</param>
+        /// <param name="zNearPlane">Depth of the near plane.</param>
+        /// <param name="zFarPlane">Depth of the far plane.</param>
+        /// <returns>The new projection <see cref="Matrix"/> for customized orthographic view.</returns>
+        public static Matrix CreateOrthographicOffCenter(Rectangle viewingVolume, float zNearPlane, float zFarPlane)
+        {
+            Matrix matrix;
+            CreateOrthographicOffCenter(viewingVolume.Left, viewingVolume.Right, viewingVolume.Bottom, viewingVolume.Top, zNearPlane, zFarPlane, out matrix);
+            return matrix;
+        }
+
+        /// <summary>
+        /// Creates a new projection <see cref="Matrix"/> for customized orthographic view.
+        /// </summary>
+        /// <param name="left">Lower x-value at the near plane.</param>
+        /// <param name="right">Upper x-value at the near plane.</param>
+        /// <param name="bottom">Lower y-coordinate at the near plane.</param>
+        /// <param name="top">Upper y-value at the near plane.</param>
+        /// <param name="zNearPlane">Depth of the near plane.</param>
+        /// <param name="zFarPlane">Depth of the far plane.</param>
+        /// <param name="result">The new projection <see cref="Matrix"/> for customized orthographic view as an output parameter.</param>
+        public static void CreateOrthographicOffCenter(float left, float right, float bottom, float top, float zNearPlane, float zFarPlane, out Matrix result)
+        {
+			result.M11 = (float)(2.0 / ((double)right - (double)left));
+			result.M12 = 0.0f;
+			result.M13 = 0.0f;
+			result.M14 = 0.0f;
+			result.M21 = 0.0f;
+			result.M22 = (float)(2.0 / ((double)top - (double)bottom));
+			result.M23 = 0.0f;
+			result.M24 = 0.0f;
+			result.M31 = 0.0f;
+			result.M32 = 0.0f;
+			result.M33 = (float)(1.0 / ((double)zNearPlane - (double)zFarPlane));
+			result.M34 = 0.0f;
+			result.M41 = (float)(((double)left + (double)right) / ((double)left - (double)right));
+			result.M42 = (float)(((double)top + (double)bottom) / ((double)bottom - (double)top));
+			result.M43 = (float)((double)zNearPlane / ((double)zNearPlane - (double)zFarPlane));
+			result.M44 = 1.0f;
+		}
+
+        /// <summary>
+        /// Creates a new projection <see cref="Matrix"/> for perspective view.
+        /// </summary>
+        /// <param name="width">Width of the viewing volume.</param>
+        /// <param name="height">Height of the viewing volume.</param>
+        /// <param name="nearPlaneDistance">Distance to the near plane.</param>
+        /// <param name="farPlaneDistance">Distance to the far plane.</param>
+        /// <returns>The new projection <see cref="Matrix"/> for perspective view.</returns>
+        public static Matrix CreatePerspective(float width, float height, float nearPlaneDistance, float farPlaneDistance)
+        {
+            Matrix matrix;
+            CreatePerspective(width, height, nearPlaneDistance, farPlaneDistance, out matrix);
+		    return matrix;
+        }
+
+        /// <summary>
+        /// Creates a new projection <see cref="Matrix"/> for perspective view.
+        /// </summary>
+        /// <param name="width">Width of the viewing volume.</param>
+        /// <param name="height">Height of the viewing volume.</param>
+        /// <param name="nearPlaneDistance">Distance to the near plane.</param>
+        /// <param name="farPlaneDistance">Distance to the far plane.</param>
+        /// <param name="result">The new projection <see cref="Matrix"/> for perspective view as an output parameter.</param>
+        public static void CreatePerspective(float width, float height, float nearPlaneDistance, float farPlaneDistance, out Matrix result)
+        {
+            if (nearPlaneDistance <= 0f)
+		    {
+		        throw new ArgumentException("nearPlaneDistance <= 0");
+		    }
+		    if (farPlaneDistance <= 0f)
+		    {
+		        throw new ArgumentException("farPlaneDistance <= 0");
+		    }
+		    if (nearPlaneDistance >= farPlaneDistance)
+		    {
+		        throw new ArgumentException("nearPlaneDistance >= farPlaneDistance");
+		    }
+		    result.M11 = (2f * nearPlaneDistance) / width;
+		    result.M12 = result.M13 = result.M14 = 0f;
+		    result.M22 = (2f * nearPlaneDistance) / height;
+		    result.M21 = result.M23 = result.M24 = 0f;
+		    result.M33 = farPlaneDistance / (nearPlaneDistance - farPlaneDistance);
+		    result.M31 = result.M32 = 0f;
+		    result.M34 = -1f;
+		    result.M41 = result.M42 = result.M44 = 0f;
+		    result.M43 = (nearPlaneDistance * farPlaneDistance) / (nearPlaneDistance - farPlaneDistance);
+        }
+
+        /// <summary>
+        /// Creates a new projection <see cref="Matrix"/> for perspective view with field of view.
+        /// </summary>
+        /// <param name="fieldOfView">Field of view in the y direction in radians.</param>
+        /// <param name="aspectRatio">Width divided by height of the viewing volume.</param>
+        /// <param name="nearPlaneDistance">Distance to the near plane.</param>
+        /// <param name="farPlaneDistance">Distance to the far plane.</param>
+        /// <returns>The new projection <see cref="Matrix"/> for perspective view with FOV.</returns>
+        public static Matrix CreatePerspectiveFieldOfView(float fieldOfView, float aspectRatio, float nearPlaneDistance, float farPlaneDistance)
+        {
+            Matrix result;
+            CreatePerspectiveFieldOfView(fieldOfView, aspectRatio, nearPlaneDistance, farPlaneDistance, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new projection <see cref="Matrix"/> for perspective view with field of view.
+        /// </summary>
+        /// <param name="fieldOfView">Field of view in the y direction in radians.</param>
+        /// <param name="aspectRatio">Width divided by height of the viewing volume.</param>
+        /// <param name="nearPlaneDistance">Distance of the near plane.</param>
+        /// <param name="farPlaneDistance">Distance of the far plane.</param>
+        /// <param name="result">The new projection <see cref="Matrix"/> for perspective view with FOV as an output parameter.</param>
+        public static void CreatePerspectiveFieldOfView(float fieldOfView, float aspectRatio, float nearPlaneDistance, float farPlaneDistance, out Matrix result)
+        {
+            if ((fieldOfView <= 0f) || (fieldOfView >= 3.141593f))
+		    {
+		        throw new ArgumentException("fieldOfView <= 0 or >= PI");
+		    }
+		    if (nearPlaneDistance <= 0f)
+		    {
+		        throw new ArgumentException("nearPlaneDistance <= 0");
+		    }
+		    if (farPlaneDistance <= 0f)
+		    {
+		        throw new ArgumentException("farPlaneDistance <= 0");
+		    }
+		    if (nearPlaneDistance >= farPlaneDistance)
+		    {
+		        throw new ArgumentException("nearPlaneDistance >= farPlaneDistance");
+		    }
+		    float num = 1f / ((float) Math.Tan((double) (fieldOfView * 0.5f)));
+		    float num9 = num / aspectRatio;
+		    result.M11 = num9;
+		    result.M12 = result.M13 = result.M14 = 0;
+		    result.M22 = num;
+		    result.M21 = result.M23 = result.M24 = 0;
+		    result.M31 = result.M32 = 0f;
+		    result.M33 = farPlaneDistance / (nearPlaneDistance - farPlaneDistance);
+		    result.M34 = -1;
+		    result.M41 = result.M42 = result.M44 = 0;
+		    result.M43 = (nearPlaneDistance * farPlaneDistance) / (nearPlaneDistance - farPlaneDistance);
+        }
+
+        /// <summary>
+        /// Creates a new projection <see cref="Matrix"/> for customized perspective view.
+        /// </summary>
+        /// <param name="left">Lower x-value at the near plane.</param>
+        /// <param name="right">Upper x-value at the near plane.</param>
+        /// <param name="bottom">Lower y-coordinate at the near plane.</param>
+        /// <param name="top">Upper y-value at the near plane.</param>
+        /// <param name="nearPlaneDistance">Distance to the near plane.</param>
+        /// <param name="farPlaneDistance">Distance to the far plane.</param>
+        /// <returns>The new <see cref="Matrix"/> for customized perspective view.</returns>
+        public static Matrix CreatePerspectiveOffCenter(float left, float right, float bottom, float top, float nearPlaneDistance, float farPlaneDistance)
+        {
+            Matrix result;
+            CreatePerspectiveOffCenter(left, right, bottom, top, nearPlaneDistance, farPlaneDistance, out result);
+            return result;
+        }
+        /// <summary>
+        /// Creates a new projection <see cref="Matrix"/> for customized perspective view.
+        /// </summary>
+        /// <param name="viewingVolume">The viewing volume.</param>
+        /// <param name="nearPlaneDistance">Distance to the near plane.</param>
+        /// <param name="farPlaneDistance">Distance to the far plane.</param>
+        /// <returns>The new <see cref="Matrix"/> for customized perspective view.</returns>
+        public static Matrix CreatePerspectiveOffCenter(Rectangle viewingVolume, float nearPlaneDistance, float farPlaneDistance)
+        {
+            Matrix result;
+            CreatePerspectiveOffCenter(viewingVolume.Left, viewingVolume.Right, viewingVolume.Bottom, viewingVolume.Top, nearPlaneDistance, farPlaneDistance, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new projection <see cref="Matrix"/> for customized perspective view.
+        /// </summary>
+        /// <param name="left">Lower x-value at the near plane.</param>
+        /// <param name="right">Upper x-value at the near plane.</param>
+        /// <param name="bottom">Lower y-coordinate at the near plane.</param>
+        /// <param name="top">Upper y-value at the near plane.</param>
+        /// <param name="nearPlaneDistance">Distance to the near plane.</param>
+        /// <param name="farPlaneDistance">Distance to the far plane.</param>
+        /// <param name="result">The new <see cref="Matrix"/> for customized perspective view as an output parameter.</param>
+        public static void CreatePerspectiveOffCenter(float left, float right, float bottom, float top, float nearPlaneDistance, float farPlaneDistance, out Matrix result)
+        {
+            if (nearPlaneDistance <= 0f)
+		    {
+		        throw new ArgumentException("nearPlaneDistance <= 0");
+		    }
+		    if (farPlaneDistance <= 0f)
+		    {
+		        throw new ArgumentException("farPlaneDistance <= 0");
+		    }
+		    if (nearPlaneDistance >= farPlaneDistance)
+		    {
+		        throw new ArgumentException("nearPlaneDistance >= farPlaneDistance");
+		    }
+		    result.M11 = (2f * nearPlaneDistance) / (right - left);
+		    result.M12 = result.M13 = result.M14 = 0;
+		    result.M22 = (2f * nearPlaneDistance) / (top - bottom);
+		    result.M21 = result.M23 = result.M24 = 0;
+		    result.M31 = (left + right) / (right - left);
+		    result.M32 = (top + bottom) / (top - bottom);
+		    result.M33 = farPlaneDistance / (nearPlaneDistance - farPlaneDistance);
+		    result.M34 = -1;
+		    result.M43 = (nearPlaneDistance * farPlaneDistance) / (nearPlaneDistance - farPlaneDistance);
+		    result.M41 = result.M42 = result.M44 = 0;
+        }
+
+        /// <summary>
+        /// Creates a new rotation <see cref="Matrix"/> around X axis.
+        /// </summary>
+        /// <param name="radians">Angle in radians.</param>
+        /// <returns>The rotation <see cref="Matrix"/> around X axis.</returns>
+        public static Matrix CreateRotationX(float radians)
+        {
+            Matrix result;
+            CreateRotationX(radians, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new rotation <see cref="Matrix"/> around X axis.
+        /// </summary>
+        /// <param name="radians">Angle in radians.</param>
+        /// <param name="result">The rotation <see cref="Matrix"/> around X axis as an output parameter.</param>
+        public static void CreateRotationX(float radians, out Matrix result)
+        {
+            result = Matrix.Identity;
+
+			var val1 = (float)Math.Cos(radians);
+			var val2 = (float)Math.Sin(radians);
+			
+            result.M22 = val1;
+            result.M23 = val2;
+            result.M32 = -val2;
+            result.M33 = val1;
+        }
+
+        /// <summary>
+        /// Creates a new rotation <see cref="Matrix"/> around Y axis.
+        /// </summary>
+        /// <param name="radians">Angle in radians.</param>
+        /// <returns>The rotation <see cref="Matrix"/> around Y axis.</returns>
+        public static Matrix CreateRotationY(float radians)
+        {
+            Matrix result;
+            CreateRotationY(radians, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new rotation <see cref="Matrix"/> around Y axis.
+        /// </summary>
+        /// <param name="radians">Angle in radians.</param>
+        /// <param name="result">The rotation <see cref="Matrix"/> around Y axis as an output parameter.</param>
+        public static void CreateRotationY(float radians, out Matrix result)
+        {
+            result = Matrix.Identity;
+
+            var val1 = (float)Math.Cos(radians);
+			var val2 = (float)Math.Sin(radians);
+			
+            result.M11 = val1;
+            result.M13 = -val2;
+            result.M31 = val2;
+            result.M33 = val1;
+        }
+
+        /// <summary>
+        /// Creates a new rotation <see cref="Matrix"/> around Z axis.
+        /// </summary>
+        /// <param name="radians">Angle in radians.</param>
+        /// <returns>The rotation <see cref="Matrix"/> around Z axis.</returns>
+        public static Matrix CreateRotationZ(float radians)
+        {
+            Matrix result;
+            CreateRotationZ(radians, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new rotation <see cref="Matrix"/> around Z axis.
+        /// </summary>
+        /// <param name="radians">Angle in radians.</param>
+        /// <param name="result">The rotation <see cref="Matrix"/> around Z axis as an output parameter.</param>
+        public static void CreateRotationZ(float radians, out Matrix result)
+        {
+            result = Matrix.Identity;
+
+			var val1 = (float)Math.Cos(radians);
+			var val2 = (float)Math.Sin(radians);
+			
+            result.M11 = val1;
+            result.M12 = val2;
+            result.M21 = -val2;
+            result.M22 = val1;
+        }
+
+        /// <summary>
+        /// Creates a new scaling <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="scale">Scale value for all three axises.</param>
+        /// <returns>The scaling <see cref="Matrix"/>.</returns>
+        public static Matrix CreateScale(float scale)
+        {
+            Matrix result;
+            CreateScale(scale, scale, scale, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new scaling <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="scale">Scale value for all three axises.</param>
+        /// <param name="result">The scaling <see cref="Matrix"/> as an output parameter.</param>
+        public static void CreateScale(float scale, out Matrix result)
+        {
+            CreateScale(scale, scale, scale, out result);
+        }
+
+        /// <summary>
+        /// Creates a new scaling <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="xScale">Scale value for X axis.</param>
+        /// <param name="yScale">Scale value for Y axis.</param>
+        /// <param name="zScale">Scale value for Z axis.</param>
+        /// <returns>The scaling <see cref="Matrix"/>.</returns>
+        public static Matrix CreateScale(float xScale, float yScale, float zScale)
+        {
+            Matrix result;
+            CreateScale(xScale, yScale, zScale, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new scaling <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="xScale">Scale value for X axis.</param>
+        /// <param name="yScale">Scale value for Y axis.</param>
+        /// <param name="zScale">Scale value for Z axis.</param>
+        /// <param name="result">The scaling <see cref="Matrix"/> as an output parameter.</param>
+        public static void CreateScale(float xScale, float yScale, float zScale, out Matrix result)
+        {
+			result.M11 = xScale;
+			result.M12 = 0;
+			result.M13 = 0;
+			result.M14 = 0;
+			result.M21 = 0;
+			result.M22 = yScale;
+			result.M23 = 0;
+			result.M24 = 0;
+			result.M31 = 0;
+			result.M32 = 0;
+			result.M33 = zScale;
+			result.M34 = 0;
+			result.M41 = 0;
+			result.M42 = 0;
+			result.M43 = 0;
+			result.M44 = 1;
+        }
+
+        /// <summary>
+        /// Creates a new scaling <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="scales"><see cref="Vector3"/> representing x,y and z scale values.</param>
+        /// <returns>The scaling <see cref="Matrix"/>.</returns>
+        public static Matrix CreateScale(Vector3 scales)
+        {
+            Matrix result;
+            CreateScale(ref scales, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new scaling <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="scales"><see cref="Vector3"/> representing x,y and z scale values.</param>
+        /// <param name="result">The scaling <see cref="Matrix"/> as an output parameter.</param>
+        public static void CreateScale(ref Vector3 scales, out Matrix result)
+        {
+            result.M11 = scales.X;
+            result.M12 = 0;
+            result.M13 = 0;
+            result.M14 = 0;
+            result.M21 = 0;
+            result.M22 = scales.Y;
+            result.M23 = 0;
+            result.M24 = 0;
+            result.M31 = 0;
+            result.M32 = 0;
+            result.M33 = scales.Z;
+            result.M34 = 0;
+            result.M41 = 0;
+            result.M42 = 0;
+            result.M43 = 0;
+            result.M44 = 1;
+        }
+
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> that flattens geometry into a specified <see cref="Plane"/> as if casting a shadow from a specified light source. 
+        /// </summary>
+        /// <param name="lightDirection">A vector specifying the direction from which the light that will cast the shadow is coming.</param>
+        /// <param name="plane">The plane onto which the new matrix should flatten geometry so as to cast a shadow.</param>
+        /// <returns>A <see cref="Matrix"/> that can be used to flatten geometry onto the specified plane from the specified direction. </returns>
+        public static Matrix CreateShadow(Vector3 lightDirection, Plane plane)
+        {
+            Matrix result;
+            CreateShadow(ref lightDirection, ref plane, out result);
+            return result;
+        }
+
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> that flattens geometry into a specified <see cref="Plane"/> as if casting a shadow from a specified light source. 
+        /// </summary>
+        /// <param name="lightDirection">A vector specifying the direction from which the light that will cast the shadow is coming.</param>
+        /// <param name="plane">The plane onto which the new matrix should flatten geometry so as to cast a shadow.</param>
+        /// <param name="result">A <see cref="Matrix"/> that can be used to flatten geometry onto the specified plane from the specified direction as an output parameter.</param>
+        public static void CreateShadow(ref Vector3 lightDirection, ref Plane plane, out Matrix result)
+        {
+            float dot = (plane.Normal.X * lightDirection.X) + (plane.Normal.Y * lightDirection.Y) + (plane.Normal.Z * lightDirection.Z);
+            float x = -plane.Normal.X;
+            float y = -plane.Normal.Y;
+            float z = -plane.Normal.Z;
+            float d = -plane.D;
+
+            result.M11 = (x * lightDirection.X) + dot;
+            result.M12 = x * lightDirection.Y;
+            result.M13 = x * lightDirection.Z;
+            result.M14 = 0;
+            result.M21 = y * lightDirection.X;
+            result.M22 = (y * lightDirection.Y) + dot;
+            result.M23 = y * lightDirection.Z;
+            result.M24 = 0;            
+            result.M31 = z * lightDirection.X;
+            result.M32 = z * lightDirection.Y;
+            result.M33 = (z * lightDirection.Z) + dot;
+            result.M34 = 0;            
+            result.M41 = d * lightDirection.X;
+            result.M42 = d * lightDirection.Y;
+            result.M43 = d * lightDirection.Z;
+            result.M44 = dot;
+        }
+        
+        /// <summary>
+        /// Creates a new translation <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="xPosition">X coordinate of translation.</param>
+        /// <param name="yPosition">Y coordinate of translation.</param>
+        /// <param name="zPosition">Z coordinate of translation.</param>
+        /// <returns>The translation <see cref="Matrix"/>.</returns>
+        public static Matrix CreateTranslation(float xPosition, float yPosition, float zPosition)
+        {
+            Matrix result;
+            CreateTranslation(xPosition, yPosition, zPosition, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new translation <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="position">X,Y and Z coordinates of translation.</param>
+        /// <param name="result">The translation <see cref="Matrix"/> as an output parameter.</param>
+        public static void CreateTranslation(ref Vector3 position, out Matrix result)
+        {
+            result.M11 = 1;
+            result.M12 = 0;
+            result.M13 = 0;
+            result.M14 = 0;
+            result.M21 = 0;
+            result.M22 = 1;
+            result.M23 = 0;
+            result.M24 = 0;
+            result.M31 = 0;
+            result.M32 = 0;
+            result.M33 = 1;
+            result.M34 = 0;
+            result.M41 = position.X;
+            result.M42 = position.Y;
+            result.M43 = position.Z;
+            result.M44 = 1;
+        }
+
+        /// <summary>
+        /// Creates a new translation <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="position">X,Y and Z coordinates of translation.</param>
+        /// <returns>The translation <see cref="Matrix"/>.</returns>
+        public static Matrix CreateTranslation(Vector3 position)
+        {
+			Matrix result;
+            CreateTranslation(ref position, out result);
+			return result;
+        }
+
+        /// <summary>
+        /// Creates a new translation <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="xPosition">X coordinate of translation.</param>
+        /// <param name="yPosition">Y coordinate of translation.</param>
+        /// <param name="zPosition">Z coordinate of translation.</param>
+        /// <param name="result">The translation <see cref="Matrix"/> as an output parameter.</param>
+        public static void CreateTranslation(float xPosition, float yPosition, float zPosition, out Matrix result)
+        {
+            result.M11 = 1;
+			result.M12 = 0;
+			result.M13 = 0;
+			result.M14 = 0;
+			result.M21 = 0;
+			result.M22 = 1;
+			result.M23 = 0;
+			result.M24 = 0;
+			result.M31 = 0;
+			result.M32 = 0;
+			result.M33 = 1;
+			result.M34 = 0;
+			result.M41 = xPosition;
+			result.M42 = yPosition;
+			result.M43 = zPosition;
+			result.M44 = 1;
+        }
+        
+        /// <summary>
+        /// Creates a new reflection <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="value">The plane that used for reflection calculation.</param>
+        /// <returns>The reflection <see cref="Matrix"/>.</returns>
+        public static Matrix CreateReflection(Plane value)
+        {
+            Matrix result;
+            CreateReflection(ref value, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new reflection <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="value">The plane that used for reflection calculation.</param>
+        /// <param name="result">The reflection <see cref="Matrix"/> as an output parameter.</param>
+        public static void CreateReflection(ref Plane value, out Matrix result)
+        {
+            Plane plane;
+            Plane.Normalize(ref value, out plane);
+            float x = plane.Normal.X;
+            float y = plane.Normal.Y;
+            float z = plane.Normal.Z;
+            float num3 = -2f * x;
+            float num2 = -2f * y;
+            float num = -2f * z;
+            result.M11 = (num3 * x) + 1f;
+            result.M12 = num2 * x;
+            result.M13 = num * x;
+            result.M14 = 0;
+            result.M21 = num3 * y;
+            result.M22 = (num2 * y) + 1;
+            result.M23 = num * y;
+            result.M24 = 0;
+            result.M31 = num3 * z;
+            result.M32 = num2 * z;
+            result.M33 = (num * z) + 1;
+            result.M34 = 0;
+            result.M41 = num3 * plane.D;
+            result.M42 = num2 * plane.D;
+            result.M43 = num * plane.D;
+            result.M44 = 1;
+        }
+
+        /// <summary>
+        /// Creates a new world <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="position">The position vector.</param>
+        /// <param name="forward">The forward direction vector.</param>
+        /// <param name="up">The upward direction vector. Usually <see cref="Vector3.Up"/>.</param>
+        /// <returns>The world <see cref="Matrix"/>.</returns>
+        public static Matrix CreateWorld(Vector3 position, Vector3 forward, Vector3 up)
+        {
+            Matrix ret;
+                        CreateWorld(ref position, ref forward, ref up, out ret);
+                        return ret;
+        }
+
+        /// <summary>
+        /// Creates a new world <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="position">The position vector.</param>
+        /// <param name="forward">The forward direction vector.</param>
+        /// <param name="up">The upward direction vector. Usually <see cref="Vector3.Up"/>.</param>
+        /// <param name="result">The world <see cref="Matrix"/> as an output parameter.</param>
+        public static void CreateWorld(ref Vector3 position, ref Vector3 forward, ref Vector3 up, out Matrix result)
+        {
+                        Vector3 x, y, z;
+                        Vector3.Normalize(ref forward, out z);
+                        Vector3.Cross(ref forward, ref up, out x);
+                        Vector3.Cross(ref x, ref forward, out y);
+                        x.Normalize();
+                        y.Normalize();            
+                        
+                        result = new Matrix();
+                        result.Right = x;
+                        result.Up = y;
+                        result.Forward = z;
+                        result.Translation = position;
+                        result.M44 = 1f;
+        }
+
+        /// <summary>
+        /// Decomposes this matrix to translation, rotation and scale elements. Returns <c>true</c> if matrix can be decomposed; <c>false</c> otherwise.
+        /// </summary>
+        /// <param name="scale">Scale vector as an output parameter.</param>
+        /// <param name="rotation">Rotation quaternion as an output parameter.</param>
+        /// <param name="translation">Translation vector as an output parameter.</param>
+        /// <returns><c>true</c> if matrix can be decomposed; <c>false</c> otherwise.</returns>
+        public bool Decompose(out Vector3 scale, out Quaternion rotation, out Vector3 translation)
+        {
+            translation.X = this.M41;
+            translation.Y = this.M42;
+            translation.Z = this.M43;
+
+            float xs = (Math.Sign(M11 * M12 * M13 * M14) < 0) ? -1 : 1;
+            float ys = (Math.Sign(M21 * M22 * M23 * M24) < 0) ? -1 : 1;
+            float zs = (Math.Sign(M31 * M32 * M33 * M34) < 0) ? -1 : 1;
+
+            scale.X = xs * (float)Math.Sqrt(this.M11 * this.M11 + this.M12 * this.M12 + this.M13 * this.M13);
+            scale.Y = ys * (float)Math.Sqrt(this.M21 * this.M21 + this.M22 * this.M22 + this.M23 * this.M23);
+            scale.Z = zs * (float)Math.Sqrt(this.M31 * this.M31 + this.M32 * this.M32 + this.M33 * this.M33);
+
+            if (scale.X == 0.0 || scale.Y == 0.0 || scale.Z == 0.0)
+            {
+                rotation = Quaternion.Identity;
+                return false;
+            }
+
+            Matrix m1 = new Matrix(this.M11 / scale.X, M12 / scale.X, M13 / scale.X, 0,
+                                   this.M21 / scale.Y, M22 / scale.Y, M23 / scale.Y, 0,
+                                   this.M31 / scale.Z, M32 / scale.Z, M33 / scale.Z, 0,
+                                   0, 0, 0, 1);
+
+            rotation = Quaternion.CreateFromRotationMatrix(m1);
+            return true;
+        }	
+
+		/// <summary>
+        /// Returns a determinant of this <see cref="Matrix"/>.
+        /// </summary>
+        /// <returns>Determinant of this <see cref="Matrix"/></returns>
+        /// <remarks>See more about determinant here - http://en.wikipedia.org/wiki/Determinant.
+        /// </remarks>
+        public float Determinant()
+        {
+            float num22 = this.M11;
+		    float num21 = this.M12;
+		    float num20 = this.M13;
+		    float num19 = this.M14;
+		    float num12 = this.M21;
+		    float num11 = this.M22;
+		    float num10 = this.M23;
+		    float num9 = this.M24;
+		    float num8 = this.M31;
+		    float num7 = this.M32;
+		    float num6 = this.M33;
+		    float num5 = this.M34;
+		    float num4 = this.M41;
+		    float num3 = this.M42;
+		    float num2 = this.M43;
+		    float num = this.M44;
+		    float num18 = (num6 * num) - (num5 * num2);
+		    float num17 = (num7 * num) - (num5 * num3);
+		    float num16 = (num7 * num2) - (num6 * num3);
+		    float num15 = (num8 * num) - (num5 * num4);
+		    float num14 = (num8 * num2) - (num6 * num4);
+		    float num13 = (num8 * num3) - (num7 * num4);
+		    return ((((num22 * (((num11 * num18) - (num10 * num17)) + (num9 * num16))) - (num21 * (((num12 * num18) - (num10 * num15)) + (num9 * num14)))) + (num20 * (((num12 * num17) - (num11 * num15)) + (num9 * num13)))) - (num19 * (((num12 * num16) - (num11 * num14)) + (num10 * num13))));
+        }
+
+        /// <summary>
+        /// Divides the elements of a <see cref="Matrix"/> by the elements of another matrix.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/>.</param>
+        /// <param name="matrix2">Divisor <see cref="Matrix"/>.</param>
+        /// <returns>The result of dividing the matrix.</returns>
+        public static Matrix Divide(Matrix matrix1, Matrix matrix2)
+        {
+		    matrix1.M11 = matrix1.M11 / matrix2.M11;
+		    matrix1.M12 = matrix1.M12 / matrix2.M12;
+		    matrix1.M13 = matrix1.M13 / matrix2.M13;
+		    matrix1.M14 = matrix1.M14 / matrix2.M14;
+		    matrix1.M21 = matrix1.M21 / matrix2.M21;
+		    matrix1.M22 = matrix1.M22 / matrix2.M22;
+		    matrix1.M23 = matrix1.M23 / matrix2.M23;
+		    matrix1.M24 = matrix1.M24 / matrix2.M24;
+		    matrix1.M31 = matrix1.M31 / matrix2.M31;
+		    matrix1.M32 = matrix1.M32 / matrix2.M32;
+		    matrix1.M33 = matrix1.M33 / matrix2.M33;
+		    matrix1.M34 = matrix1.M34 / matrix2.M34;
+		    matrix1.M41 = matrix1.M41 / matrix2.M41;
+		    matrix1.M42 = matrix1.M42 / matrix2.M42;
+		    matrix1.M43 = matrix1.M43 / matrix2.M43;
+		    matrix1.M44 = matrix1.M44 / matrix2.M44;
+		    return matrix1;
+        }
+
+        /// <summary>
+        /// Divides the elements of a <see cref="Matrix"/> by the elements of another matrix.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/>.</param>
+        /// <param name="matrix2">Divisor <see cref="Matrix"/>.</param>
+        /// <param name="result">The result of dividing the matrix as an output parameter.</param>
+        public static void Divide(ref Matrix matrix1, ref Matrix matrix2, out Matrix result)
+        {
+            result.M11 = matrix1.M11 / matrix2.M11;
+		    result.M12 = matrix1.M12 / matrix2.M12;
+		    result.M13 = matrix1.M13 / matrix2.M13;
+		    result.M14 = matrix1.M14 / matrix2.M14;
+		    result.M21 = matrix1.M21 / matrix2.M21;
+		    result.M22 = matrix1.M22 / matrix2.M22;
+		    result.M23 = matrix1.M23 / matrix2.M23;
+		    result.M24 = matrix1.M24 / matrix2.M24;
+		    result.M31 = matrix1.M31 / matrix2.M31;
+		    result.M32 = matrix1.M32 / matrix2.M32;
+		    result.M33 = matrix1.M33 / matrix2.M33;
+		    result.M34 = matrix1.M34 / matrix2.M34;
+		    result.M41 = matrix1.M41 / matrix2.M41;
+		    result.M42 = matrix1.M42 / matrix2.M42;
+		    result.M43 = matrix1.M43 / matrix2.M43;
+		    result.M44 = matrix1.M44 / matrix2.M44;
+        }
+
+        /// <summary>
+        /// Divides the elements of a <see cref="Matrix"/> by a scalar.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/>.</param>
+        /// <param name="divider">Divisor scalar.</param>
+        /// <returns>The result of dividing a matrix by a scalar.</returns>
+        public static Matrix Divide(Matrix matrix1, float divider)
+        {
+		    float num = 1f / divider;
+		    matrix1.M11 = matrix1.M11 * num;
+		    matrix1.M12 = matrix1.M12 * num;
+		    matrix1.M13 = matrix1.M13 * num;
+		    matrix1.M14 = matrix1.M14 * num;
+		    matrix1.M21 = matrix1.M21 * num;
+		    matrix1.M22 = matrix1.M22 * num;
+		    matrix1.M23 = matrix1.M23 * num;
+		    matrix1.M24 = matrix1.M24 * num;
+		    matrix1.M31 = matrix1.M31 * num;
+		    matrix1.M32 = matrix1.M32 * num;
+		    matrix1.M33 = matrix1.M33 * num;
+		    matrix1.M34 = matrix1.M34 * num;
+		    matrix1.M41 = matrix1.M41 * num;
+		    matrix1.M42 = matrix1.M42 * num;
+		    matrix1.M43 = matrix1.M43 * num;
+		    matrix1.M44 = matrix1.M44 * num;
+		    return matrix1;
+        }
+
+        /// <summary>
+        /// Divides the elements of a <see cref="Matrix"/> by a scalar.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/>.</param>
+        /// <param name="divider">Divisor scalar.</param>
+        /// <param name="result">The result of dividing a matrix by a scalar as an output parameter.</param>
+        public static void Divide(ref Matrix matrix1, float divider, out Matrix result)
+        {
+            float num = 1f / divider;
+		    result.M11 = matrix1.M11 * num;
+		    result.M12 = matrix1.M12 * num;
+		    result.M13 = matrix1.M13 * num;
+		    result.M14 = matrix1.M14 * num;
+		    result.M21 = matrix1.M21 * num;
+		    result.M22 = matrix1.M22 * num;
+		    result.M23 = matrix1.M23 * num;
+		    result.M24 = matrix1.M24 * num;
+		    result.M31 = matrix1.M31 * num;
+		    result.M32 = matrix1.M32 * num;
+		    result.M33 = matrix1.M33 * num;
+		    result.M34 = matrix1.M34 * num;
+		    result.M41 = matrix1.M41 * num;
+		    result.M42 = matrix1.M42 * num;
+		    result.M43 = matrix1.M43 * num;
+		    result.M44 = matrix1.M44 * num;
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Matrix"/> without any tolerance.
+        /// </summary>
+        /// <param name="other">The <see cref="Matrix"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public bool Equals(Matrix other)
+        {
+            return ((((((this.M11 == other.M11) && (this.M22 == other.M22)) && ((this.M33 == other.M33) && (this.M44 == other.M44))) && (((this.M12 == other.M12) && (this.M13 == other.M13)) && ((this.M14 == other.M14) && (this.M21 == other.M21)))) && ((((this.M23 == other.M23) && (this.M24 == other.M24)) && ((this.M31 == other.M31) && (this.M32 == other.M32))) && (((this.M34 == other.M34) && (this.M41 == other.M41)) && (this.M42 == other.M42)))) && (this.M43 == other.M43));
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Object"/> without any tolerance.
+        /// </summary>
+        /// <param name="obj">The <see cref="Object"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            bool flag = false;
+		    if (obj is Matrix)
+		    {
+		        flag = this.Equals((Matrix) obj);
+		    }
+		    return flag;
+        }
+
+        /// <summary>
+        /// Gets the hash code of this <see cref="Matrix"/>.
+        /// </summary>
+        /// <returns>Hash code of this <see cref="Matrix"/>.</returns>
+        public override int GetHashCode()
+        {
+            return (((((((((((((((this.M11.GetHashCode() + this.M12.GetHashCode()) + this.M13.GetHashCode()) + this.M14.GetHashCode()) + this.M21.GetHashCode()) + this.M22.GetHashCode()) + this.M23.GetHashCode()) + this.M24.GetHashCode()) + this.M31.GetHashCode()) + this.M32.GetHashCode()) + this.M33.GetHashCode()) + this.M34.GetHashCode()) + this.M41.GetHashCode()) + this.M42.GetHashCode()) + this.M43.GetHashCode()) + this.M44.GetHashCode());
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> which contains inversion of the specified matrix. 
+        /// </summary>
+        /// <param name="matrix">Source <see cref="Matrix"/>.</param>
+        /// <returns>The inverted matrix.</returns>
+        public static Matrix Invert(Matrix matrix)
+        {
+            Matrix result;
+            Invert(ref matrix, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> which contains inversion of the specified matrix. 
+        /// </summary>
+        /// <param name="matrix">Source <see cref="Matrix"/>.</param>
+        /// <param name="result">The inverted matrix as output parameter.</param>
+        public static void Invert(ref Matrix matrix, out Matrix result)
+        {
+			float num1 = matrix.M11;
+			float num2 = matrix.M12;
+			float num3 = matrix.M13;
+			float num4 = matrix.M14;
+			float num5 = matrix.M21;
+			float num6 = matrix.M22;
+			float num7 = matrix.M23;
+			float num8 = matrix.M24;
+			float num9 = matrix.M31;
+			float num10 = matrix.M32;
+			float num11 = matrix.M33;
+			float num12 = matrix.M34;
+			float num13 = matrix.M41;
+			float num14 = matrix.M42;
+			float num15 = matrix.M43;
+			float num16 = matrix.M44;
+			float num17 = (float) ((double) num11 * (double) num16 - (double) num12 * (double) num15);
+			float num18 = (float) ((double) num10 * (double) num16 - (double) num12 * (double) num14);
+			float num19 = (float) ((double) num10 * (double) num15 - (double) num11 * (double) num14);
+			float num20 = (float) ((double) num9 * (double) num16 - (double) num12 * (double) num13);
+			float num21 = (float) ((double) num9 * (double) num15 - (double) num11 * (double) num13);
+			float num22 = (float) ((double) num9 * (double) num14 - (double) num10 * (double) num13);
+			float num23 = (float) ((double) num6 * (double) num17 - (double) num7 * (double) num18 + (double) num8 * (double) num19);
+			float num24 = (float) -((double) num5 * (double) num17 - (double) num7 * (double) num20 + (double) num8 * (double) num21);
+			float num25 = (float) ((double) num5 * (double) num18 - (double) num6 * (double) num20 + (double) num8 * (double) num22);
+			float num26 = (float) -((double) num5 * (double) num19 - (double) num6 * (double) num21 + (double) num7 * (double) num22);
+			float num27 = (float) (1.0 / ((double) num1 * (double) num23 + (double) num2 * (double) num24 + (double) num3 * (double) num25 + (double) num4 * (double) num26));
+			
+			result.M11 = num23 * num27;
+			result.M21 = num24 * num27;
+			result.M31 = num25 * num27;
+			result.M41 = num26 * num27;
+			result.M12 = (float) -((double) num2 * (double) num17 - (double) num3 * (double) num18 + (double) num4 * (double) num19) * num27;
+			result.M22 = (float) ((double) num1 * (double) num17 - (double) num3 * (double) num20 + (double) num4 * (double) num21) * num27;
+			result.M32 = (float) -((double) num1 * (double) num18 - (double) num2 * (double) num20 + (double) num4 * (double) num22) * num27;
+			result.M42 = (float) ((double) num1 * (double) num19 - (double) num2 * (double) num21 + (double) num3 * (double) num22) * num27;
+			float num28 = (float) ((double) num7 * (double) num16 - (double) num8 * (double) num15);
+			float num29 = (float) ((double) num6 * (double) num16 - (double) num8 * (double) num14);
+			float num30 = (float) ((double) num6 * (double) num15 - (double) num7 * (double) num14);
+			float num31 = (float) ((double) num5 * (double) num16 - (double) num8 * (double) num13);
+			float num32 = (float) ((double) num5 * (double) num15 - (double) num7 * (double) num13);
+			float num33 = (float) ((double) num5 * (double) num14 - (double) num6 * (double) num13);
+			result.M13 = (float) ((double) num2 * (double) num28 - (double) num3 * (double) num29 + (double) num4 * (double) num30) * num27;
+			result.M23 = (float) -((double) num1 * (double) num28 - (double) num3 * (double) num31 + (double) num4 * (double) num32) * num27;
+			result.M33 = (float) ((double) num1 * (double) num29 - (double) num2 * (double) num31 + (double) num4 * (double) num33) * num27;
+			result.M43 = (float) -((double) num1 * (double) num30 - (double) num2 * (double) num32 + (double) num3 * (double) num33) * num27;
+			float num34 = (float) ((double) num7 * (double) num12 - (double) num8 * (double) num11);
+			float num35 = (float) ((double) num6 * (double) num12 - (double) num8 * (double) num10);
+			float num36 = (float) ((double) num6 * (double) num11 - (double) num7 * (double) num10);
+			float num37 = (float) ((double) num5 * (double) num12 - (double) num8 * (double) num9);
+			float num38 = (float) ((double) num5 * (double) num11 - (double) num7 * (double) num9);
+			float num39 = (float) ((double) num5 * (double) num10 - (double) num6 * (double) num9);
+			result.M14 = (float) -((double) num2 * (double) num34 - (double) num3 * (double) num35 + (double) num4 * (double) num36) * num27;
+			result.M24 = (float) ((double) num1 * (double) num34 - (double) num3 * (double) num37 + (double) num4 * (double) num38) * num27;
+			result.M34 = (float) -((double) num1 * (double) num35 - (double) num2 * (double) num37 + (double) num4 * (double) num39) * num27;
+			result.M44 = (float) ((double) num1 * (double) num36 - (double) num2 * (double) num38 + (double) num3 * (double) num39) * num27;
+			
+			
+			/*
+			
+			
+            ///
+            // Use Laplace expansion theorem to calculate the inverse of a 4x4 matrix
+            // 
+            // 1. Calculate the 2x2 determinants needed the 4x4 determinant based on the 2x2 determinants 
+            // 3. Create the adjugate matrix, which satisfies: A * adj(A) = det(A) * I
+            // 4. Divide adjugate matrix with the determinant to find the inverse
+            
+            float det1, det2, det3, det4, det5, det6, det7, det8, det9, det10, det11, det12;
+            float detMatrix;
+            FindDeterminants(ref matrix, out detMatrix, out det1, out det2, out det3, out det4, out det5, out det6, 
+                             out det7, out det8, out det9, out det10, out det11, out det12);
+            
+            float invDetMatrix = 1f / detMatrix;
+            
+            Matrix ret; // Allow for matrix and result to point to the same structure
+            
+            ret.M11 = (matrix.M22*det12 - matrix.M23*det11 + matrix.M24*det10) * invDetMatrix;
+            ret.M12 = (-matrix.M12*det12 + matrix.M13*det11 - matrix.M14*det10) * invDetMatrix;
+            ret.M13 = (matrix.M42*det6 - matrix.M43*det5 + matrix.M44*det4) * invDetMatrix;
+            ret.M14 = (-matrix.M32*det6 + matrix.M33*det5 - matrix.M34*det4) * invDetMatrix;
+            ret.M21 = (-matrix.M21*det12 + matrix.M23*det9 - matrix.M24*det8) * invDetMatrix;
+            ret.M22 = (matrix.M11*det12 - matrix.M13*det9 + matrix.M14*det8) * invDetMatrix;
+            ret.M23 = (-matrix.M41*det6 + matrix.M43*det3 - matrix.M44*det2) * invDetMatrix;
+            ret.M24 = (matrix.M31*det6 - matrix.M33*det3 + matrix.M34*det2) * invDetMatrix;
+            ret.M31 = (matrix.M21*det11 - matrix.M22*det9 + matrix.M24*det7) * invDetMatrix;
+            ret.M32 = (-matrix.M11*det11 + matrix.M12*det9 - matrix.M14*det7) * invDetMatrix;
+            ret.M33 = (matrix.M41*det5 - matrix.M42*det3 + matrix.M44*det1) * invDetMatrix;
+            ret.M34 = (-matrix.M31*det5 + matrix.M32*det3 - matrix.M34*det1) * invDetMatrix;
+            ret.M41 = (-matrix.M21*det10 + matrix.M22*det8 - matrix.M23*det7) * invDetMatrix;
+            ret.M42 = (matrix.M11*det10 - matrix.M12*det8 + matrix.M13*det7) * invDetMatrix;
+            ret.M43 = (-matrix.M41*det4 + matrix.M42*det2 - matrix.M43*det1) * invDetMatrix;
+            ret.M44 = (matrix.M31*det4 - matrix.M32*det2 + matrix.M33*det1) * invDetMatrix;
+            
+            result = ret;
+            */
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> that contains linear interpolation of the values in specified matrixes.
+        /// </summary>
+        /// <param name="matrix1">The first <see cref="Matrix"/>.</param>
+        /// <param name="matrix2">The second <see cref="Vector2"/>.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <returns>>The result of linear interpolation of the specified matrixes.</returns>
+        public static Matrix Lerp(Matrix matrix1, Matrix matrix2, float amount)
+        {
+		    matrix1.M11 = matrix1.M11 + ((matrix2.M11 - matrix1.M11) * amount);
+		    matrix1.M12 = matrix1.M12 + ((matrix2.M12 - matrix1.M12) * amount);
+		    matrix1.M13 = matrix1.M13 + ((matrix2.M13 - matrix1.M13) * amount);
+		    matrix1.M14 = matrix1.M14 + ((matrix2.M14 - matrix1.M14) * amount);
+		    matrix1.M21 = matrix1.M21 + ((matrix2.M21 - matrix1.M21) * amount);
+		    matrix1.M22 = matrix1.M22 + ((matrix2.M22 - matrix1.M22) * amount);
+		    matrix1.M23 = matrix1.M23 + ((matrix2.M23 - matrix1.M23) * amount);
+		    matrix1.M24 = matrix1.M24 + ((matrix2.M24 - matrix1.M24) * amount);
+		    matrix1.M31 = matrix1.M31 + ((matrix2.M31 - matrix1.M31) * amount);
+		    matrix1.M32 = matrix1.M32 + ((matrix2.M32 - matrix1.M32) * amount);
+		    matrix1.M33 = matrix1.M33 + ((matrix2.M33 - matrix1.M33) * amount);
+		    matrix1.M34 = matrix1.M34 + ((matrix2.M34 - matrix1.M34) * amount);
+		    matrix1.M41 = matrix1.M41 + ((matrix2.M41 - matrix1.M41) * amount);
+		    matrix1.M42 = matrix1.M42 + ((matrix2.M42 - matrix1.M42) * amount);
+		    matrix1.M43 = matrix1.M43 + ((matrix2.M43 - matrix1.M43) * amount);
+		    matrix1.M44 = matrix1.M44 + ((matrix2.M44 - matrix1.M44) * amount);
+		    return matrix1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> that contains linear interpolation of the values in specified matrixes.
+        /// </summary>
+        /// <param name="matrix1">The first <see cref="Matrix"/>.</param>
+        /// <param name="matrix2">The second <see cref="Vector2"/>.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <param name="result">The result of linear interpolation of the specified matrixes as an output parameter.</param>
+        public static void Lerp(ref Matrix matrix1, ref Matrix matrix2, float amount, out Matrix result)
+        {
+            result.M11 = matrix1.M11 + ((matrix2.M11 - matrix1.M11) * amount);
+		    result.M12 = matrix1.M12 + ((matrix2.M12 - matrix1.M12) * amount);
+		    result.M13 = matrix1.M13 + ((matrix2.M13 - matrix1.M13) * amount);
+		    result.M14 = matrix1.M14 + ((matrix2.M14 - matrix1.M14) * amount);
+		    result.M21 = matrix1.M21 + ((matrix2.M21 - matrix1.M21) * amount);
+		    result.M22 = matrix1.M22 + ((matrix2.M22 - matrix1.M22) * amount);
+		    result.M23 = matrix1.M23 + ((matrix2.M23 - matrix1.M23) * amount);
+		    result.M24 = matrix1.M24 + ((matrix2.M24 - matrix1.M24) * amount);
+		    result.M31 = matrix1.M31 + ((matrix2.M31 - matrix1.M31) * amount);
+		    result.M32 = matrix1.M32 + ((matrix2.M32 - matrix1.M32) * amount);
+		    result.M33 = matrix1.M33 + ((matrix2.M33 - matrix1.M33) * amount);
+		    result.M34 = matrix1.M34 + ((matrix2.M34 - matrix1.M34) * amount);
+		    result.M41 = matrix1.M41 + ((matrix2.M41 - matrix1.M41) * amount);
+		    result.M42 = matrix1.M42 + ((matrix2.M42 - matrix1.M42) * amount);
+		    result.M43 = matrix1.M43 + ((matrix2.M43 - matrix1.M43) * amount);
+		    result.M44 = matrix1.M44 + ((matrix2.M44 - matrix1.M44) * amount);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> that contains a multiplication of two matrix.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/>.</param>
+        /// <param name="matrix2">Source <see cref="Matrix"/>.</param>
+        /// <returns>Result of the matrix multiplication.</returns>
+        public static Matrix Multiply(Matrix matrix1, Matrix matrix2)
+        {
+            var m11 = (((matrix1.M11 * matrix2.M11) + (matrix1.M12 * matrix2.M21)) + (matrix1.M13 * matrix2.M31)) + (matrix1.M14 * matrix2.M41);
+            var m12 = (((matrix1.M11 * matrix2.M12) + (matrix1.M12 * matrix2.M22)) + (matrix1.M13 * matrix2.M32)) + (matrix1.M14 * matrix2.M42);
+            var m13 = (((matrix1.M11 * matrix2.M13) + (matrix1.M12 * matrix2.M23)) + (matrix1.M13 * matrix2.M33)) + (matrix1.M14 * matrix2.M43);
+            var m14 = (((matrix1.M11 * matrix2.M14) + (matrix1.M12 * matrix2.M24)) + (matrix1.M13 * matrix2.M34)) + (matrix1.M14 * matrix2.M44);
+            var m21 = (((matrix1.M21 * matrix2.M11) + (matrix1.M22 * matrix2.M21)) + (matrix1.M23 * matrix2.M31)) + (matrix1.M24 * matrix2.M41);
+            var m22 = (((matrix1.M21 * matrix2.M12) + (matrix1.M22 * matrix2.M22)) + (matrix1.M23 * matrix2.M32)) + (matrix1.M24 * matrix2.M42);
+            var m23 = (((matrix1.M21 * matrix2.M13) + (matrix1.M22 * matrix2.M23)) + (matrix1.M23 * matrix2.M33)) + (matrix1.M24 * matrix2.M43);
+            var m24 = (((matrix1.M21 * matrix2.M14) + (matrix1.M22 * matrix2.M24)) + (matrix1.M23 * matrix2.M34)) + (matrix1.M24 * matrix2.M44);
+            var m31 = (((matrix1.M31 * matrix2.M11) + (matrix1.M32 * matrix2.M21)) + (matrix1.M33 * matrix2.M31)) + (matrix1.M34 * matrix2.M41);
+            var m32 = (((matrix1.M31 * matrix2.M12) + (matrix1.M32 * matrix2.M22)) + (matrix1.M33 * matrix2.M32)) + (matrix1.M34 * matrix2.M42);
+            var m33 = (((matrix1.M31 * matrix2.M13) + (matrix1.M32 * matrix2.M23)) + (matrix1.M33 * matrix2.M33)) + (matrix1.M34 * matrix2.M43);
+            var m34 = (((matrix1.M31 * matrix2.M14) + (matrix1.M32 * matrix2.M24)) + (matrix1.M33 * matrix2.M34)) + (matrix1.M34 * matrix2.M44);
+            var m41 = (((matrix1.M41 * matrix2.M11) + (matrix1.M42 * matrix2.M21)) + (matrix1.M43 * matrix2.M31)) + (matrix1.M44 * matrix2.M41);
+            var m42 = (((matrix1.M41 * matrix2.M12) + (matrix1.M42 * matrix2.M22)) + (matrix1.M43 * matrix2.M32)) + (matrix1.M44 * matrix2.M42);
+            var m43 = (((matrix1.M41 * matrix2.M13) + (matrix1.M42 * matrix2.M23)) + (matrix1.M43 * matrix2.M33)) + (matrix1.M44 * matrix2.M43);
+           	var m44 = (((matrix1.M41 * matrix2.M14) + (matrix1.M42 * matrix2.M24)) + (matrix1.M43 * matrix2.M34)) + (matrix1.M44 * matrix2.M44);
+            matrix1.M11 = m11;
+			matrix1.M12 = m12;
+			matrix1.M13 = m13;
+			matrix1.M14 = m14;
+			matrix1.M21 = m21;
+			matrix1.M22 = m22;
+			matrix1.M23 = m23;
+			matrix1.M24 = m24;
+			matrix1.M31 = m31;
+			matrix1.M32 = m32;
+			matrix1.M33 = m33;
+			matrix1.M34 = m34;
+			matrix1.M41 = m41;
+			matrix1.M42 = m42;
+			matrix1.M43 = m43;
+			matrix1.M44 = m44;
+			return matrix1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> that contains a multiplication of two matrix.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/>.</param>
+        /// <param name="matrix2">Source <see cref="Matrix"/>.</param>
+        /// <param name="result">Result of the matrix multiplication as an output parameter.</param>
+        public static void Multiply(ref Matrix matrix1, ref Matrix matrix2, out Matrix result)
+        {
+            var m11 = (((matrix1.M11 * matrix2.M11) + (matrix1.M12 * matrix2.M21)) + (matrix1.M13 * matrix2.M31)) + (matrix1.M14 * matrix2.M41);
+            var m12 = (((matrix1.M11 * matrix2.M12) + (matrix1.M12 * matrix2.M22)) + (matrix1.M13 * matrix2.M32)) + (matrix1.M14 * matrix2.M42);
+            var m13 = (((matrix1.M11 * matrix2.M13) + (matrix1.M12 * matrix2.M23)) + (matrix1.M13 * matrix2.M33)) + (matrix1.M14 * matrix2.M43);
+            var m14 = (((matrix1.M11 * matrix2.M14) + (matrix1.M12 * matrix2.M24)) + (matrix1.M13 * matrix2.M34)) + (matrix1.M14 * matrix2.M44);
+            var m21 = (((matrix1.M21 * matrix2.M11) + (matrix1.M22 * matrix2.M21)) + (matrix1.M23 * matrix2.M31)) + (matrix1.M24 * matrix2.M41);
+            var m22 = (((matrix1.M21 * matrix2.M12) + (matrix1.M22 * matrix2.M22)) + (matrix1.M23 * matrix2.M32)) + (matrix1.M24 * matrix2.M42);
+            var m23 = (((matrix1.M21 * matrix2.M13) + (matrix1.M22 * matrix2.M23)) + (matrix1.M23 * matrix2.M33)) + (matrix1.M24 * matrix2.M43);
+            var m24 = (((matrix1.M21 * matrix2.M14) + (matrix1.M22 * matrix2.M24)) + (matrix1.M23 * matrix2.M34)) + (matrix1.M24 * matrix2.M44);
+            var m31 = (((matrix1.M31 * matrix2.M11) + (matrix1.M32 * matrix2.M21)) + (matrix1.M33 * matrix2.M31)) + (matrix1.M34 * matrix2.M41);
+            var m32 = (((matrix1.M31 * matrix2.M12) + (matrix1.M32 * matrix2.M22)) + (matrix1.M33 * matrix2.M32)) + (matrix1.M34 * matrix2.M42);
+            var m33 = (((matrix1.M31 * matrix2.M13) + (matrix1.M32 * matrix2.M23)) + (matrix1.M33 * matrix2.M33)) + (matrix1.M34 * matrix2.M43);
+            var m34 = (((matrix1.M31 * matrix2.M14) + (matrix1.M32 * matrix2.M24)) + (matrix1.M33 * matrix2.M34)) + (matrix1.M34 * matrix2.M44);
+            var m41 = (((matrix1.M41 * matrix2.M11) + (matrix1.M42 * matrix2.M21)) + (matrix1.M43 * matrix2.M31)) + (matrix1.M44 * matrix2.M41);
+            var m42 = (((matrix1.M41 * matrix2.M12) + (matrix1.M42 * matrix2.M22)) + (matrix1.M43 * matrix2.M32)) + (matrix1.M44 * matrix2.M42);
+            var m43 = (((matrix1.M41 * matrix2.M13) + (matrix1.M42 * matrix2.M23)) + (matrix1.M43 * matrix2.M33)) + (matrix1.M44 * matrix2.M43);
+           	var m44 = (((matrix1.M41 * matrix2.M14) + (matrix1.M42 * matrix2.M24)) + (matrix1.M43 * matrix2.M34)) + (matrix1.M44 * matrix2.M44);
+            result.M11 = m11;
+			result.M12 = m12;
+			result.M13 = m13;
+			result.M14 = m14;
+			result.M21 = m21;
+			result.M22 = m22;
+			result.M23 = m23;
+			result.M24 = m24;
+			result.M31 = m31;
+			result.M32 = m32;
+			result.M33 = m33;
+			result.M34 = m34;
+			result.M41 = m41;
+			result.M42 = m42;
+			result.M43 = m43;
+			result.M44 = m44;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> that contains a multiplication of <see cref="Matrix"/> and a scalar.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/>.</param>
+        /// <param name="scaleFactor">Scalar value.</param>
+        /// <returns>Result of the matrix multiplication with a scalar.</returns>
+        public static Matrix Multiply(Matrix matrix1, float scaleFactor)
+        {
+            matrix1.M11 *= scaleFactor;
+            matrix1.M12 *= scaleFactor;
+            matrix1.M13 *= scaleFactor;
+            matrix1.M14 *= scaleFactor;
+            matrix1.M21 *= scaleFactor;
+            matrix1.M22 *= scaleFactor;
+            matrix1.M23 *= scaleFactor;
+            matrix1.M24 *= scaleFactor;
+            matrix1.M31 *= scaleFactor;
+            matrix1.M32 *= scaleFactor;
+            matrix1.M33 *= scaleFactor;
+            matrix1.M34 *= scaleFactor;
+            matrix1.M41 *= scaleFactor;
+            matrix1.M42 *= scaleFactor;
+            matrix1.M43 *= scaleFactor;
+            matrix1.M44 *= scaleFactor;
+            return matrix1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> that contains a multiplication of <see cref="Matrix"/> and a scalar.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/>.</param>
+        /// <param name="scaleFactor">Scalar value.</param>
+        /// <param name="result">Result of the matrix multiplication with a scalar as an output parameter.</param>
+        public static void Multiply(ref Matrix matrix1, float scaleFactor, out Matrix result)
+        {
+            result.M11 = matrix1.M11 * scaleFactor;
+            result.M12 = matrix1.M12 * scaleFactor;
+            result.M13 = matrix1.M13 * scaleFactor;
+            result.M14 = matrix1.M14 * scaleFactor;
+            result.M21 = matrix1.M21 * scaleFactor;
+            result.M22 = matrix1.M22 * scaleFactor;
+            result.M23 = matrix1.M23 * scaleFactor;
+            result.M24 = matrix1.M24 * scaleFactor;
+            result.M31 = matrix1.M31 * scaleFactor;
+            result.M32 = matrix1.M32 * scaleFactor;
+            result.M33 = matrix1.M33 * scaleFactor;
+            result.M34 = matrix1.M34 * scaleFactor;
+            result.M41 = matrix1.M41 * scaleFactor;
+            result.M42 = matrix1.M42 * scaleFactor;
+            result.M43 = matrix1.M43 * scaleFactor;
+            result.M44 = matrix1.M44 * scaleFactor;
+
+        }
+
+        /// <summary>
+        /// Copy the values of specified <see cref="Matrix"/> to the float array.
+        /// </summary>
+        /// <param name="matrix">The source <see cref="Matrix"/>.</param>
+        /// <returns>The array which matrix values will be stored.</returns>
+        /// <remarks>
+        /// Required for OpenGL 2.0 projection matrix stuff.
+        /// </remarks>
+        public static float[] ToFloatArray(Matrix matrix)
+        {
+            float[] matarray = {
+									matrix.M11, matrix.M12, matrix.M13, matrix.M14,
+									matrix.M21, matrix.M22, matrix.M23, matrix.M24,
+									matrix.M31, matrix.M32, matrix.M33, matrix.M34,
+									matrix.M41, matrix.M42, matrix.M43, matrix.M44
+								};
+            return matarray;
+        }
+
+        /// <summary>
+        /// Returns a matrix with the all values negated.
+        /// </summary>
+        /// <param name="matrix">Source <see cref="Matrix"/>.</param>
+        /// <returns>Result of the matrix negation.</returns>
+        public static Matrix Negate(Matrix matrix)
+        {
+		    matrix.M11 = -matrix.M11;
+		    matrix.M12 = -matrix.M12;
+		    matrix.M13 = -matrix.M13;
+		    matrix.M14 = -matrix.M14;
+		    matrix.M21 = -matrix.M21;
+		    matrix.M22 = -matrix.M22;
+		    matrix.M23 = -matrix.M23;
+		    matrix.M24 = -matrix.M24;
+		    matrix.M31 = -matrix.M31;
+		    matrix.M32 = -matrix.M32;
+		    matrix.M33 = -matrix.M33;
+		    matrix.M34 = -matrix.M34;
+		    matrix.M41 = -matrix.M41;
+		    matrix.M42 = -matrix.M42;
+		    matrix.M43 = -matrix.M43;
+		    matrix.M44 = -matrix.M44;
+		    return matrix;
+        }
+
+        /// <summary>
+        /// Returns a matrix with the all values negated.
+        /// </summary>
+        /// <param name="matrix">Source <see cref="Matrix"/>.</param>
+        /// <param name="result">Result of the matrix negation as an output parameter.</param>
+        public static void Negate(ref Matrix matrix, out Matrix result)
+        {
+            result.M11 = -matrix.M11;
+		    result.M12 = -matrix.M12;
+		    result.M13 = -matrix.M13;
+		    result.M14 = -matrix.M14;
+		    result.M21 = -matrix.M21;
+		    result.M22 = -matrix.M22;
+		    result.M23 = -matrix.M23;
+		    result.M24 = -matrix.M24;
+		    result.M31 = -matrix.M31;
+		    result.M32 = -matrix.M32;
+		    result.M33 = -matrix.M33;
+		    result.M34 = -matrix.M34;
+		    result.M41 = -matrix.M41;
+		    result.M42 = -matrix.M42;
+		    result.M43 = -matrix.M43;
+		    result.M44 = -matrix.M44;
+        }
+
+        /// <summary>
+        /// Adds two matrixes.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/> on the left of the add sign.</param>
+        /// <param name="matrix2">Source <see cref="Matrix"/> on the right of the add sign.</param>
+        /// <returns>Sum of the matrixes.</returns>
+        public static Matrix operator +(Matrix matrix1, Matrix matrix2)
+        {
+            matrix1.M11 = matrix1.M11 + matrix2.M11;
+            matrix1.M12 = matrix1.M12 + matrix2.M12;
+            matrix1.M13 = matrix1.M13 + matrix2.M13;
+            matrix1.M14 = matrix1.M14 + matrix2.M14;
+            matrix1.M21 = matrix1.M21 + matrix2.M21;
+            matrix1.M22 = matrix1.M22 + matrix2.M22;
+            matrix1.M23 = matrix1.M23 + matrix2.M23;
+            matrix1.M24 = matrix1.M24 + matrix2.M24;
+            matrix1.M31 = matrix1.M31 + matrix2.M31;
+            matrix1.M32 = matrix1.M32 + matrix2.M32;
+            matrix1.M33 = matrix1.M33 + matrix2.M33;
+            matrix1.M34 = matrix1.M34 + matrix2.M34;
+            matrix1.M41 = matrix1.M41 + matrix2.M41;
+            matrix1.M42 = matrix1.M42 + matrix2.M42;
+            matrix1.M43 = matrix1.M43 + matrix2.M43;
+            matrix1.M44 = matrix1.M44 + matrix2.M44;
+            return matrix1;
+        }
+
+        /// <summary>
+        /// Divides the elements of a <see cref="Matrix"/> by the elements of another <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/> on the left of the div sign.</param>
+        /// <param name="matrix2">Divisor <see cref="Matrix"/> on the right of the div sign.</param>
+        /// <returns>The result of dividing the matrixes.</returns>
+        public static Matrix operator /(Matrix matrix1, Matrix matrix2)
+        {
+		    matrix1.M11 = matrix1.M11 / matrix2.M11;
+		    matrix1.M12 = matrix1.M12 / matrix2.M12;
+		    matrix1.M13 = matrix1.M13 / matrix2.M13;
+		    matrix1.M14 = matrix1.M14 / matrix2.M14;
+		    matrix1.M21 = matrix1.M21 / matrix2.M21;
+		    matrix1.M22 = matrix1.M22 / matrix2.M22;
+		    matrix1.M23 = matrix1.M23 / matrix2.M23;
+		    matrix1.M24 = matrix1.M24 / matrix2.M24;
+		    matrix1.M31 = matrix1.M31 / matrix2.M31;
+		    matrix1.M32 = matrix1.M32 / matrix2.M32;
+		    matrix1.M33 = matrix1.M33 / matrix2.M33;
+		    matrix1.M34 = matrix1.M34 / matrix2.M34;
+		    matrix1.M41 = matrix1.M41 / matrix2.M41;
+		    matrix1.M42 = matrix1.M42 / matrix2.M42;
+		    matrix1.M43 = matrix1.M43 / matrix2.M43;
+		    matrix1.M44 = matrix1.M44 / matrix2.M44;
+		    return matrix1;
+        }
+
+        /// <summary>
+        /// Divides the elements of a <see cref="Matrix"/> by a scalar.
+        /// </summary>
+        /// <param name="matrix">Source <see cref="Matrix"/> on the left of the div sign.</param>
+        /// <param name="divider">Divisor scalar on the right of the div sign.</param>
+        /// <returns>The result of dividing a matrix by a scalar.</returns>
+        public static Matrix operator /(Matrix matrix, float divider)
+        {
+		    float num = 1f / divider;
+		    matrix.M11 = matrix.M11 * num;
+		    matrix.M12 = matrix.M12 * num;
+		    matrix.M13 = matrix.M13 * num;
+		    matrix.M14 = matrix.M14 * num;
+		    matrix.M21 = matrix.M21 * num;
+		    matrix.M22 = matrix.M22 * num;
+		    matrix.M23 = matrix.M23 * num;
+		    matrix.M24 = matrix.M24 * num;
+		    matrix.M31 = matrix.M31 * num;
+		    matrix.M32 = matrix.M32 * num;
+		    matrix.M33 = matrix.M33 * num;
+		    matrix.M34 = matrix.M34 * num;
+		    matrix.M41 = matrix.M41 * num;
+		    matrix.M42 = matrix.M42 * num;
+		    matrix.M43 = matrix.M43 * num;
+		    matrix.M44 = matrix.M44 * num;
+		    return matrix;
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="Matrix"/> instances are equal without any tolerance.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/> on the left of the equal sign.</param>
+        /// <param name="matrix2">Source <see cref="Matrix"/> on the right of the equal sign.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix matrix1, Matrix matrix2)
+        {
+            return (
+                matrix1.M11 == matrix2.M11 &&
+                matrix1.M12 == matrix2.M12 &&
+                matrix1.M13 == matrix2.M13 &&
+                matrix1.M14 == matrix2.M14 &&
+                matrix1.M21 == matrix2.M21 &&
+                matrix1.M22 == matrix2.M22 &&
+                matrix1.M23 == matrix2.M23 &&
+                matrix1.M24 == matrix2.M24 &&
+                matrix1.M31 == matrix2.M31 &&
+                matrix1.M32 == matrix2.M32 &&
+                matrix1.M33 == matrix2.M33 &&
+                matrix1.M34 == matrix2.M34 &&
+                matrix1.M41 == matrix2.M41 &&
+                matrix1.M42 == matrix2.M42 &&
+                matrix1.M43 == matrix2.M43 &&
+                matrix1.M44 == matrix2.M44                  
+                );
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="Matrix"/> instances are not equal without any tolerance.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/> on the left of the not equal sign.</param>
+        /// <param name="matrix2">Source <see cref="Matrix"/> on the right of the not equal sign.</param>
+        /// <returns><c>true</c> if the instances are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix matrix1, Matrix matrix2)
+        {
+            return (
+                matrix1.M11 != matrix2.M11 ||
+                matrix1.M12 != matrix2.M12 ||
+                matrix1.M13 != matrix2.M13 ||
+                matrix1.M14 != matrix2.M14 ||
+                matrix1.M21 != matrix2.M21 ||
+                matrix1.M22 != matrix2.M22 ||
+                matrix1.M23 != matrix2.M23 ||
+                matrix1.M24 != matrix2.M24 ||
+                matrix1.M31 != matrix2.M31 ||
+                matrix1.M32 != matrix2.M32 ||
+                matrix1.M33 != matrix2.M33 ||
+                matrix1.M34 != matrix2.M34 || 
+                matrix1.M41 != matrix2.M41 ||
+                matrix1.M42 != matrix2.M42 ||
+                matrix1.M43 != matrix2.M43 ||
+                matrix1.M44 != matrix2.M44                  
+                );
+        }
+
+        /// <summary>
+        /// Multiplies two matrixes.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/> on the left of the mul sign.</param>
+        /// <param name="matrix2">Source <see cref="Matrix"/> on the right of the mul sign.</param>
+        /// <returns>Result of the matrix multiplication.</returns>
+        /// <remarks>
+        /// Using matrix multiplication algorithm - see http://en.wikipedia.org/wiki/Matrix_multiplication.
+        /// </remarks>
+        public static Matrix operator *(Matrix matrix1, Matrix matrix2)
+        {
+            var m11 = (((matrix1.M11 * matrix2.M11) + (matrix1.M12 * matrix2.M21)) + (matrix1.M13 * matrix2.M31)) + (matrix1.M14 * matrix2.M41);
+            var m12 = (((matrix1.M11 * matrix2.M12) + (matrix1.M12 * matrix2.M22)) + (matrix1.M13 * matrix2.M32)) + (matrix1.M14 * matrix2.M42);
+            var m13 = (((matrix1.M11 * matrix2.M13) + (matrix1.M12 * matrix2.M23)) + (matrix1.M13 * matrix2.M33)) + (matrix1.M14 * matrix2.M43);
+            var m14 = (((matrix1.M11 * matrix2.M14) + (matrix1.M12 * matrix2.M24)) + (matrix1.M13 * matrix2.M34)) + (matrix1.M14 * matrix2.M44);
+            var m21 = (((matrix1.M21 * matrix2.M11) + (matrix1.M22 * matrix2.M21)) + (matrix1.M23 * matrix2.M31)) + (matrix1.M24 * matrix2.M41);
+            var m22 = (((matrix1.M21 * matrix2.M12) + (matrix1.M22 * matrix2.M22)) + (matrix1.M23 * matrix2.M32)) + (matrix1.M24 * matrix2.M42);
+            var m23 = (((matrix1.M21 * matrix2.M13) + (matrix1.M22 * matrix2.M23)) + (matrix1.M23 * matrix2.M33)) + (matrix1.M24 * matrix2.M43);
+            var m24 = (((matrix1.M21 * matrix2.M14) + (matrix1.M22 * matrix2.M24)) + (matrix1.M23 * matrix2.M34)) + (matrix1.M24 * matrix2.M44);
+            var m31 = (((matrix1.M31 * matrix2.M11) + (matrix1.M32 * matrix2.M21)) + (matrix1.M33 * matrix2.M31)) + (matrix1.M34 * matrix2.M41);
+            var m32 = (((matrix1.M31 * matrix2.M12) + (matrix1.M32 * matrix2.M22)) + (matrix1.M33 * matrix2.M32)) + (matrix1.M34 * matrix2.M42);
+            var m33 = (((matrix1.M31 * matrix2.M13) + (matrix1.M32 * matrix2.M23)) + (matrix1.M33 * matrix2.M33)) + (matrix1.M34 * matrix2.M43);
+            var m34 = (((matrix1.M31 * matrix2.M14) + (matrix1.M32 * matrix2.M24)) + (matrix1.M33 * matrix2.M34)) + (matrix1.M34 * matrix2.M44);
+            var m41 = (((matrix1.M41 * matrix2.M11) + (matrix1.M42 * matrix2.M21)) + (matrix1.M43 * matrix2.M31)) + (matrix1.M44 * matrix2.M41);
+            var m42 = (((matrix1.M41 * matrix2.M12) + (matrix1.M42 * matrix2.M22)) + (matrix1.M43 * matrix2.M32)) + (matrix1.M44 * matrix2.M42);
+            var m43 = (((matrix1.M41 * matrix2.M13) + (matrix1.M42 * matrix2.M23)) + (matrix1.M43 * matrix2.M33)) + (matrix1.M44 * matrix2.M43);
+           	var m44 = (((matrix1.M41 * matrix2.M14) + (matrix1.M42 * matrix2.M24)) + (matrix1.M43 * matrix2.M34)) + (matrix1.M44 * matrix2.M44);
+            matrix1.M11 = m11;
+			matrix1.M12 = m12;
+			matrix1.M13 = m13;
+			matrix1.M14 = m14;
+			matrix1.M21 = m21;
+			matrix1.M22 = m22;
+			matrix1.M23 = m23;
+			matrix1.M24 = m24;
+			matrix1.M31 = m31;
+			matrix1.M32 = m32;
+			matrix1.M33 = m33;
+			matrix1.M34 = m34;
+			matrix1.M41 = m41;
+			matrix1.M42 = m42;
+			matrix1.M43 = m43;
+			matrix1.M44 = m44;
+			return matrix1;
+        }
+
+        /// <summary>
+        /// Multiplies the elements of matrix by a scalar.
+        /// </summary>
+        /// <param name="matrix">Source <see cref="Matrix"/> on the left of the mul sign.</param>
+        /// <param name="scaleFactor">Scalar value on the right of the mul sign.</param>
+        /// <returns>Result of the matrix multiplication with a scalar.</returns>
+        public static Matrix operator *(Matrix matrix, float scaleFactor)
+        {
+		    matrix.M11 = matrix.M11 * scaleFactor;
+		    matrix.M12 = matrix.M12 * scaleFactor;
+		    matrix.M13 = matrix.M13 * scaleFactor;
+		    matrix.M14 = matrix.M14 * scaleFactor;
+		    matrix.M21 = matrix.M21 * scaleFactor;
+		    matrix.M22 = matrix.M22 * scaleFactor;
+		    matrix.M23 = matrix.M23 * scaleFactor;
+		    matrix.M24 = matrix.M24 * scaleFactor;
+		    matrix.M31 = matrix.M31 * scaleFactor;
+		    matrix.M32 = matrix.M32 * scaleFactor;
+		    matrix.M33 = matrix.M33 * scaleFactor;
+		    matrix.M34 = matrix.M34 * scaleFactor;
+		    matrix.M41 = matrix.M41 * scaleFactor;
+		    matrix.M42 = matrix.M42 * scaleFactor;
+		    matrix.M43 = matrix.M43 * scaleFactor;
+		    matrix.M44 = matrix.M44 * scaleFactor;
+		    return matrix;
+        }
+
+        /// <summary>
+        /// Subtracts the values of one <see cref="Matrix"/> from another <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="matrix1">Source <see cref="Matrix"/> on the left of the sub sign.</param>
+        /// <param name="matrix2">Source <see cref="Matrix"/> on the right of the sub sign.</param>
+        /// <returns>Result of the matrix subtraction.</returns>
+        public static Matrix operator -(Matrix matrix1, Matrix matrix2)
+        {
+		    matrix1.M11 = matrix1.M11 - matrix2.M11;
+		    matrix1.M12 = matrix1.M12 - matrix2.M12;
+		    matrix1.M13 = matrix1.M13 - matrix2.M13;
+		    matrix1.M14 = matrix1.M14 - matrix2.M14;
+		    matrix1.M21 = matrix1.M21 - matrix2.M21;
+		    matrix1.M22 = matrix1.M22 - matrix2.M22;
+		    matrix1.M23 = matrix1.M23 - matrix2.M23;
+		    matrix1.M24 = matrix1.M24 - matrix2.M24;
+		    matrix1.M31 = matrix1.M31 - matrix2.M31;
+		    matrix1.M32 = matrix1.M32 - matrix2.M32;
+		    matrix1.M33 = matrix1.M33 - matrix2.M33;
+		    matrix1.M34 = matrix1.M34 - matrix2.M34;
+		    matrix1.M41 = matrix1.M41 - matrix2.M41;
+		    matrix1.M42 = matrix1.M42 - matrix2.M42;
+		    matrix1.M43 = matrix1.M43 - matrix2.M43;
+		    matrix1.M44 = matrix1.M44 - matrix2.M44;
+		    return matrix1;
+        }
+
+        /// <summary>
+        /// Inverts values in the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="matrix">Source <see cref="Matrix"/> on the right of the sub sign.</param>
+        /// <returns>Result of the inversion.</returns>
+        public static Matrix operator -(Matrix matrix)
+        {
+		    matrix.M11 = -matrix.M11;
+		    matrix.M12 = -matrix.M12;
+		    matrix.M13 = -matrix.M13;
+		    matrix.M14 = -matrix.M14;
+		    matrix.M21 = -matrix.M21;
+		    matrix.M22 = -matrix.M22;
+		    matrix.M23 = -matrix.M23;
+		    matrix.M24 = -matrix.M24;
+		    matrix.M31 = -matrix.M31;
+		    matrix.M32 = -matrix.M32;
+		    matrix.M33 = -matrix.M33;
+		    matrix.M34 = -matrix.M34;
+		    matrix.M41 = -matrix.M41;
+		    matrix.M42 = -matrix.M42;
+		    matrix.M43 = -matrix.M43;
+		    matrix.M44 = -matrix.M44;
+			return matrix;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> that contains subtraction of one matrix from another.
+        /// </summary>
+        /// <param name="matrix1">The first <see cref="Matrix"/>.</param>
+        /// <param name="matrix2">The second <see cref="Matrix"/>.</param>
+        /// <returns>The result of the matrix subtraction.</returns>
+        public static Matrix Subtract(Matrix matrix1, Matrix matrix2)
+        {
+		    matrix1.M11 = matrix1.M11 - matrix2.M11;
+		    matrix1.M12 = matrix1.M12 - matrix2.M12;
+		    matrix1.M13 = matrix1.M13 - matrix2.M13;
+		    matrix1.M14 = matrix1.M14 - matrix2.M14;
+		    matrix1.M21 = matrix1.M21 - matrix2.M21;
+		    matrix1.M22 = matrix1.M22 - matrix2.M22;
+		    matrix1.M23 = matrix1.M23 - matrix2.M23;
+		    matrix1.M24 = matrix1.M24 - matrix2.M24;
+		    matrix1.M31 = matrix1.M31 - matrix2.M31;
+		    matrix1.M32 = matrix1.M32 - matrix2.M32;
+		    matrix1.M33 = matrix1.M33 - matrix2.M33;
+		    matrix1.M34 = matrix1.M34 - matrix2.M34;
+		    matrix1.M41 = matrix1.M41 - matrix2.M41;
+		    matrix1.M42 = matrix1.M42 - matrix2.M42;
+		    matrix1.M43 = matrix1.M43 - matrix2.M43;
+		    matrix1.M44 = matrix1.M44 - matrix2.M44;
+		    return matrix1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Matrix"/> that contains subtraction of one matrix from another.
+        /// </summary>
+        /// <param name="matrix1">The first <see cref="Matrix"/>.</param>
+        /// <param name="matrix2">The second <see cref="Matrix"/>.</param>
+        /// <param name="result">The result of the matrix subtraction as an output parameter.</param>
+        public static void Subtract(ref Matrix matrix1, ref Matrix matrix2, out Matrix result)
+        {
+            result.M11 = matrix1.M11 - matrix2.M11;
+		    result.M12 = matrix1.M12 - matrix2.M12;
+		    result.M13 = matrix1.M13 - matrix2.M13;
+		    result.M14 = matrix1.M14 - matrix2.M14;
+		    result.M21 = matrix1.M21 - matrix2.M21;
+		    result.M22 = matrix1.M22 - matrix2.M22;
+		    result.M23 = matrix1.M23 - matrix2.M23;
+		    result.M24 = matrix1.M24 - matrix2.M24;
+		    result.M31 = matrix1.M31 - matrix2.M31;
+		    result.M32 = matrix1.M32 - matrix2.M32;
+		    result.M33 = matrix1.M33 - matrix2.M33;
+		    result.M34 = matrix1.M34 - matrix2.M34;
+		    result.M41 = matrix1.M41 - matrix2.M41;
+		    result.M42 = matrix1.M42 - matrix2.M42;
+		    result.M43 = matrix1.M43 - matrix2.M43;
+		    result.M44 = matrix1.M44 - matrix2.M44;
+        }
+
+        internal string DebugDisplayString
+        {
+            get
+            {
+                if (this == Identity)
+                {
+                    return "Identity";
+                }
+
+                return string.Concat(
+                     "( ", this.M11.ToString(), "  ", this.M12.ToString(), "  ", this.M13.ToString(), "  ", this.M14.ToString(), " )  \r\n",
+                     "( ", this.M21.ToString(), "  ", this.M22.ToString(), "  ", this.M23.ToString(), "  ", this.M24.ToString(), " )  \r\n",
+                     "( ", this.M31.ToString(), "  ", this.M32.ToString(), "  ", this.M33.ToString(), "  ", this.M34.ToString(), " )  \r\n",
+                     "( ", this.M41.ToString(), "  ", this.M42.ToString(), "  ", this.M43.ToString(), "  ", this.M44.ToString(), " )");
+            }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="String"/> representation of this <see cref="Matrix"/> in the format:
+        /// {M11:[<see cref="M11"/>] M12:[<see cref="M12"/>] M13:[<see cref="M13"/>] M14:[<see cref="M14"/>]}
+        /// {M21:[<see cref="M21"/>] M12:[<see cref="M22"/>] M13:[<see cref="M23"/>] M14:[<see cref="M24"/>]}
+        /// {M31:[<see cref="M31"/>] M32:[<see cref="M32"/>] M33:[<see cref="M33"/>] M34:[<see cref="M34"/>]}
+        /// {M41:[<see cref="M41"/>] M42:[<see cref="M42"/>] M43:[<see cref="M43"/>] M44:[<see cref="M44"/>]}
+        /// </summary>
+        /// <returns>A <see cref="String"/> representation of this <see cref="Matrix"/>.</returns>
+        public override string ToString()
+        {
+            return "{M11:" + M11 + " M12:" + M12 + " M13:" + M13 + " M14:" + M14 + "}"
+                + " {M21:" + M21 + " M22:" + M22 + " M23:" + M23 + " M24:" + M24 + "}"
+                + " {M31:" + M31 + " M32:" + M32 + " M33:" + M33 + " M34:" + M34 + "}"
+                + " {M41:" + M41 + " M42:" + M42 + " M43:" + M43 + " M44:" + M44 + "}";
+        }
+
+        /// <summary>
+        /// Swap the matrix rows and columns.
+        /// </summary>
+        /// <param name="matrix">The matrix for transposing operation.</param>
+        /// <returns>The new <see cref="Matrix"/> which contains the transposing result.</returns>
+        public static Matrix Transpose(Matrix matrix)
+        {
+            Matrix ret;
+            Transpose(ref matrix, out ret);
+            return ret;
+        }
+
+        /// <summary>
+        /// Swap the matrix rows and columns.
+        /// </summary>
+        /// <param name="matrix">The matrix for transposing operation.</param>
+        /// <param name="result">The new <see cref="Matrix"/> which contains the transposing result as an output parameter.</param>
+        public static void Transpose(ref Matrix matrix, out Matrix result)
+        {
+            Matrix ret;
+            
+            ret.M11 = matrix.M11;
+            ret.M12 = matrix.M21;
+            ret.M13 = matrix.M31;
+            ret.M14 = matrix.M41;
+
+            ret.M21 = matrix.M12;
+            ret.M22 = matrix.M22;
+            ret.M23 = matrix.M32;
+            ret.M24 = matrix.M42;
+
+            ret.M31 = matrix.M13;
+            ret.M32 = matrix.M23;
+            ret.M33 = matrix.M33;
+            ret.M34 = matrix.M43;
+
+            ret.M41 = matrix.M14;
+            ret.M42 = matrix.M24;
+            ret.M43 = matrix.M34;
+            ret.M44 = matrix.M44;
+            
+            result = ret;
+        }
+        #endregion
+		
+		#region Private Static Methods
+        
+        /// <summary>
+        /// Helper method for using the Laplace expansion theorem using two rows expansions to calculate major and 
+        /// minor determinants of a 4x4 matrix. This method is used for inverting a matrix.
+        /// </summary>
+        private static void FindDeterminants(ref Matrix matrix, out float major, 
+                                             out float minor1, out float minor2, out float minor3, out float minor4, out float minor5, out float minor6,
+                                             out float minor7, out float minor8, out float minor9, out float minor10, out float minor11, out float minor12)
+        {
+                double det1 = (double)matrix.M11 * (double)matrix.M22 - (double)matrix.M12 * (double)matrix.M21;
+                double det2 = (double)matrix.M11 * (double)matrix.M23 - (double)matrix.M13 * (double)matrix.M21;
+                double det3 = (double)matrix.M11 * (double)matrix.M24 - (double)matrix.M14 * (double)matrix.M21;
+                double det4 = (double)matrix.M12 * (double)matrix.M23 - (double)matrix.M13 * (double)matrix.M22;
+                double det5 = (double)matrix.M12 * (double)matrix.M24 - (double)matrix.M14 * (double)matrix.M22;
+                double det6 = (double)matrix.M13 * (double)matrix.M24 - (double)matrix.M14 * (double)matrix.M23;
+                double det7 = (double)matrix.M31 * (double)matrix.M42 - (double)matrix.M32 * (double)matrix.M41;
+                double det8 = (double)matrix.M31 * (double)matrix.M43 - (double)matrix.M33 * (double)matrix.M41;
+                double det9 = (double)matrix.M31 * (double)matrix.M44 - (double)matrix.M34 * (double)matrix.M41;
+                double det10 = (double)matrix.M32 * (double)matrix.M43 - (double)matrix.M33 * (double)matrix.M42;
+                double det11 = (double)matrix.M32 * (double)matrix.M44 - (double)matrix.M34 * (double)matrix.M42;
+                double det12 = (double)matrix.M33 * (double)matrix.M44 - (double)matrix.M34 * (double)matrix.M43;
+                
+                major = (float)(det1*det12 - det2*det11 + det3*det10 + det4*det9 - det5*det8 + det6*det7);
+                minor1 = (float)det1;
+                minor2 = (float)det2;
+                minor3 = (float)det3;
+                minor4 = (float)det4;
+                minor5 = (float)det5;
+                minor6 = (float)det6;
+                minor7 = (float)det7;
+                minor8 = (float)det8;
+                minor9 = (float)det9;
+                minor10 = (float)det10;
+                minor11 = (float)det11;
+                minor12 = (float)det12;
+        }
+		
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Media/Album.cs b/MonoGame.Framework/Media/Album.cs
new file mode 100644
index 00000000000..2817f4906dc
--- /dev/null
+++ b/MonoGame.Framework/Media/Album.cs
@@ -0,0 +1,240 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+#if WINDOWS_UAP
+using Windows.Storage.FileProperties;
+#elif IOS
+using System.Drawing;
+using CoreGraphics;
+using MediaPlayer;
+using UIKit;
+#elif ANDROID
+using Android.Graphics;
+using Android.Provider;
+#endif
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed class Album : IDisposable
+    {
+        private Artist artist;
+        private Genre genre;
+        private string album;
+        private SongCollection songCollection;
+#if WINDOWS_UAP
+        private StorageItemThumbnail thumbnail;
+#elif IOS && !TVOS
+        private MPMediaItemArtwork thumbnail;
+#elif ANDROID
+        private Android.Net.Uri thumbnail;
+#endif
+
+        public Artist Artist
+        {
+            get
+            {
+                return this.artist;
+            }
+        }
+
+        /// <summary>
+        /// Gets the duration of the Album.
+        /// </summary>
+        public TimeSpan Duration
+        {
+            get
+            {
+                return TimeSpan.Zero; // Not implemented
+            }
+        }
+
+        /// <summary>
+        /// Gets the Genre of the Album.
+        /// </summary>
+        public Genre Genre
+        {
+            get
+            {
+                return this.genre;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the Album has associated album art.
+        /// </summary>
+        public bool HasArt
+        {
+            get
+            {
+#if WINDOWS_UAP
+                return this.thumbnail != null;
+#elif IOS && !TVOS
+                // If album art is missing the bounds will be: Infinity, Infinity, 0, 0
+                return this.thumbnail != null && this.thumbnail.Bounds.Width != 0;
+#elif ANDROID
+                return this.thumbnail != null;
+#else
+                return false;
+#endif
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the object is disposed.
+        /// </summary>
+        public bool IsDisposed
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets the name of the Album.
+        /// </summary>
+        public string Name
+        {
+            get
+            {
+                return this.album;
+            }
+        }
+
+        /// <summary>
+        /// Gets a SongCollection that contains the songs on the album.
+        /// </summary>
+        public SongCollection Songs
+        {
+            get
+            {
+                return this.songCollection;
+            }
+        }
+
+       private Album(SongCollection songCollection, string name, Artist artist, Genre genre)
+        {
+            this.songCollection = songCollection;
+            this.album = name;
+            this.artist = artist;
+            this.genre = genre;
+        }
+#if WINDOWS_UAP
+        internal Album(SongCollection songCollection, string name, Artist artist, Genre genre, StorageItemThumbnail thumbnail)
+            : this(songCollection, name, artist, genre)
+        {
+            this.thumbnail = thumbnail;
+        }
+#elif IOS && !TVOS
+        internal Album(SongCollection songCollection, string name, Artist artist, Genre genre, MPMediaItemArtwork thumbnail)
+            : this(songCollection, name, artist, genre)
+        {
+            this.thumbnail = thumbnail;
+        }
+#elif ANDROID
+        internal Album(SongCollection songCollection, string name, Artist artist, Genre genre, Android.Net.Uri thumbnail)
+            : this(songCollection, name, artist, genre)
+        {
+            this.thumbnail = thumbnail;
+        }
+#endif
+
+        /// <summary>
+        /// Immediately releases the unmanaged resources used by this object.
+        /// </summary>
+        public void Dispose()
+        {
+#if WINDOWS_UAP
+            if (this.thumbnail != null)
+                this.thumbnail.Dispose();
+#endif
+        }
+        
+#if IOS && !TVOS
+        [CLSCompliant(false)]
+        public UIImage GetAlbumArt(int width = 0, int height = 0)
+        {
+            if (width == 0)
+                width = (int)this.thumbnail.Bounds.Width;
+            if (height == 0)
+                height = (int)this.thumbnail.Bounds.Height;
+
+			return this.thumbnail.ImageWithSize(new CGSize(width, height));
+        }
+#elif ANDROID
+        [CLSCompliant(false)]
+        public Bitmap GetAlbumArt(int width = 0, int height = 0)
+        {
+            var albumArt = MediaStore.Images.Media.GetBitmap(MediaLibrary.Context.ContentResolver, this.thumbnail);
+            if (width == 0 || height == 0)
+                return albumArt;
+
+            var scaledAlbumArt = Bitmap.CreateScaledBitmap(albumArt, width, height, true);
+            albumArt.Dispose();
+            return scaledAlbumArt;
+        }
+#else
+        /// <summary>
+        /// Returns the stream that contains the album art image data.
+        /// </summary>
+        public Stream GetAlbumArt()
+        {
+#if WINDOWS_UAP
+            if (this.HasArt)
+                return this.thumbnail.AsStream();
+            return null;
+#else
+            throw new NotImplementedException();
+#endif
+        }
+#endif
+
+#if IOS && !TVOS
+        [CLSCompliant(false)]
+        public UIImage GetThumbnail()
+        {
+            return this.GetAlbumArt(220, 220);
+        }
+#elif ANDROID
+        [CLSCompliant(false)]
+        public Bitmap GetThumbnail()
+        {
+            return this.GetAlbumArt(220, 220);
+        }
+#else
+        /// <summary>
+        /// Returns the stream that contains the album thumbnail image data.
+        /// </summary>
+        public Stream GetThumbnail()
+        {
+#if WINDOWS_UAP
+            if (this.HasArt)
+                return this.thumbnail.AsStream();
+
+            return null;
+#else
+            throw new NotImplementedException();
+#endif
+        }
+#endif
+
+		/// <summary>
+        /// Returns a String representation of this Album.
+        /// </summary>
+        public override string ToString()
+        {
+            return this.album.ToString();
+        }
+
+        /// <summary>
+        /// Gets the hash code for this instance.
+        /// </summary>
+        public override int GetHashCode()
+        {
+            return this.album.GetHashCode();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/AlbumCollection.cs b/MonoGame.Framework/Media/AlbumCollection.cs
new file mode 100644
index 00000000000..120756b2c6e
--- /dev/null
+++ b/MonoGame.Framework/Media/AlbumCollection.cs
@@ -0,0 +1,63 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed class AlbumCollection : IDisposable
+    {
+        private List<Album> albumCollection;
+
+        /// <summary>
+        /// Gets the number of Album objects in the AlbumCollection.
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                return this.albumCollection.Count;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the object is disposed.
+        /// </summary>
+        public bool IsDisposed
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public AlbumCollection(List<Album> albums)
+        {
+            this.albumCollection = albums;
+        }
+
+        /// <summary>
+        /// Gets the Album at the specified index in the AlbumCollection.
+        /// </summary>
+        /// <param name="index">Index of the Album to get.</param>
+        public Album this[int index]
+        {
+            get
+            {
+                return this.albumCollection[index];
+            }
+        }
+
+        /// <summary>
+        /// Immediately releases the unmanaged resources used by this object.
+        /// </summary>
+        public void Dispose()
+        {
+            foreach (var album in this.albumCollection)
+                album.Dispose();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/Artist.cs b/MonoGame.Framework/Media/Artist.cs
new file mode 100644
index 00000000000..e4ff6a55233
--- /dev/null
+++ b/MonoGame.Framework/Media/Artist.cs
@@ -0,0 +1,85 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed class Artist : IDisposable
+    {
+        private string artist;
+
+        /// <summary>
+        /// Gets the AlbumCollection for the Artist.
+        /// </summary>
+        public AlbumCollection Albums
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the object is disposed.
+        /// </summary>
+        public bool IsDisposed
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Gets the name of the Artist.
+        /// </summary>
+        public string Name
+        {
+            get
+            {
+                return this.artist;
+            }
+        }
+
+        /// <summary>
+        /// Gets the SongCollection for the Artist.
+        /// </summary>
+        public SongCollection Songs
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public Artist(string artist)
+        {
+            this.artist = artist;
+        }
+
+        /// <summary>
+        /// Immediately releases the unmanaged resources used by this object.
+        /// </summary>
+        public void Dispose()
+        {
+        }
+
+        /// <summary>
+        /// Returns a String representation of the Artist.
+        /// </summary>
+        public override string ToString()
+        {
+            return this.artist.ToString();
+        }
+
+        /// <summary>
+        /// Gets the hash code for this instance.
+        /// </summary>
+        public override int GetHashCode()
+        {
+            return this.artist.GetHashCode();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/Genre.cs b/MonoGame.Framework/Media/Genre.cs
new file mode 100644
index 00000000000..3156a238b70
--- /dev/null
+++ b/MonoGame.Framework/Media/Genre.cs
@@ -0,0 +1,85 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed class Genre : IDisposable
+    {
+        private string genre;
+
+        /// <summary>
+        /// Gets the AlbumCollection for the Genre.
+        /// </summary>
+        public AlbumCollection Albums
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the object is disposed.
+        /// </summary>
+        public bool IsDisposed
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Gets the name of the Genre.
+        /// </summary>
+        public string Name
+        {
+            get
+            {
+                return this.genre;
+            }
+        }
+
+        /// <summary>
+        /// Gets the SongCollection for the Genre.
+        /// </summary>
+        public SongCollection Songs
+        {
+            get
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public Genre(string genre)
+        {
+            this.genre = genre;
+        }
+
+        /// <summary>
+        /// Immediately releases the unmanaged resources used by this object.
+        /// </summary>
+        public void Dispose()
+        {
+        }
+
+        /// <summary>
+        /// Returns a String representation of the Genre.
+        /// </summary>
+        public override string ToString()
+        {
+            return this.genre;
+        }
+
+        /// <summary>
+        /// Gets the hash code for this instance.
+        /// </summary>
+        public override int GetHashCode()
+        {
+            return this.genre.GetHashCode();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/MediaLibrary.Android.cs b/MonoGame.Framework/Media/MediaLibrary.Android.cs
new file mode 100644
index 00000000000..c5378a00bec
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaLibrary.Android.cs
@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using Android.Content;
+using Android.Provider;
+using Uri = Android.Net.Uri;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public partial class MediaLibrary
+    {
+        private static readonly TimeSpan MinimumSongDuration = TimeSpan.FromSeconds(3);
+
+        internal static Context Context { get; set; }
+
+        private static AlbumCollection albumCollection;
+        private static SongCollection songCollection;
+
+        private void PlatformLoad(Action<int> progressCallback)
+        {
+            List<Song> songList = new List<Song>();
+            List<Album> albumList = new List<Album>();
+
+            using (var musicCursor = Context.ContentResolver.Query(MediaStore.Audio.Media.ExternalContentUri, null, null, null, null))
+            {
+                if (musicCursor != null)
+                {
+                    Dictionary<string, Artist> artists = new Dictionary<string, Artist>();
+                    Dictionary<string, Album> albums = new Dictionary<string, Album>();
+                    Dictionary<string, Genre> genres = new Dictionary<string, Genre>();
+
+                    // Note: Grabbing album art using MediaStore.Audio.AlbumColumns.AlbumArt and
+                    // MediaStore.Audio.AudioColumns.AlbumArt is broken
+                    // See: https://code.google.com/p/android/issues/detail?id=1630
+                    // Workaround: http://stackoverflow.com/questions/1954434/cover-art-on-android
+
+                    int albumNameColumn = musicCursor.GetColumnIndex(MediaStore.Audio.AlbumColumns.Album);
+                    int albumArtistColumn = musicCursor.GetColumnIndex(MediaStore.Audio.AlbumColumns.Artist);
+                    int albumIdColumn = musicCursor.GetColumnIndex(MediaStore.Audio.AlbumColumns.AlbumId);
+                    int genreColumn = musicCursor.GetColumnIndex(MediaStore.Audio.GenresColumns.Name); // Also broken :(
+
+                    int artistColumn = musicCursor.GetColumnIndex(MediaStore.Audio.AudioColumns.Artist);
+                    int titleColumn = musicCursor.GetColumnIndex(MediaStore.Audio.AudioColumns.Title);
+                    int durationColumn = musicCursor.GetColumnIndex(MediaStore.Audio.AudioColumns.Duration);
+                    int assetIdColumn = musicCursor.GetColumnIndex(MediaStore.Audio.AudioColumns.Id);
+
+                    if (titleColumn == -1 || durationColumn == -1 || assetIdColumn == -1)
+                    {
+                        Debug.WriteLine("Missing essential properties from music library. Returning empty library.");
+                        albumCollection = new AlbumCollection(albumList);
+                        songCollection = new SongCollection(songList);
+                        return;
+                    }
+
+                    for (musicCursor.MoveToFirst(); !musicCursor.IsAfterLast; musicCursor.MoveToNext())
+                        try
+                        {
+                            long durationProperty = musicCursor.GetLong(durationColumn);
+                            TimeSpan duration = TimeSpan.FromMilliseconds(durationProperty);
+
+                            // Exclude sound effects
+                            if (duration < MinimumSongDuration)
+                                continue;
+
+                            string albumNameProperty = (albumNameColumn > -1 ? musicCursor.GetString(albumNameColumn) : null) ?? "Unknown Album";
+                            string albumArtistProperty = (albumArtistColumn > -1 ? musicCursor.GetString(albumArtistColumn) : null) ?? "Unknown Artist";
+                            string genreProperty = (genreColumn > -1 ? musicCursor.GetString(genreColumn) : null) ?? "Unknown Genre";
+                            string artistProperty = (artistColumn > -1 ? musicCursor.GetString(artistColumn) : null) ?? "Unknown Artist";
+                            string titleProperty = musicCursor.GetString(titleColumn);
+
+                            long assetId = musicCursor.GetLong(assetIdColumn);
+                            var assetUri = ContentUris.WithAppendedId(MediaStore.Audio.Media.ExternalContentUri, assetId);
+                            long albumId = albumIdColumn > -1 ? musicCursor.GetInt(albumIdColumn) : -1;
+                            var albumArtUri = albumId > -1 ? ContentUris.WithAppendedId(Uri.Parse("content://media/external/audio/albumart"), albumId) : null;
+
+                            Artist artist;
+                            if (!artists.TryGetValue(artistProperty, out artist))
+                            {
+                                artist = new Artist(artistProperty);
+                                artists.Add(artist.Name, artist);
+                            }
+
+                            Artist albumArtist;
+                            if (!artists.TryGetValue(albumArtistProperty, out albumArtist))
+                            {
+                                albumArtist = new Artist(albumArtistProperty);
+                                artists.Add(albumArtist.Name, albumArtist);
+                            }
+
+                            Genre genre;
+                            if (!genres.TryGetValue(genreProperty, out genre))
+                            {
+                                genre = new Genre(genreProperty);
+                                genres.Add(genre.Name, genre);
+                            }
+
+                            Album album;
+                            if (!albums.TryGetValue(albumNameProperty, out album))
+                            {
+                                album = new Album(new SongCollection(), albumNameProperty, albumArtist, genre, albumArtUri);
+                                albums.Add(album.Name, album);
+                                albumList.Add(album);
+                            }
+
+                            var song = new Song(album, artist, genre, titleProperty, duration, assetUri);
+                            song.Album.Songs.Add(song);
+                            songList.Add(song);
+                        }
+                        catch (Exception e)
+                        {
+                            Debug.WriteLine("MediaLibrary exception: " + e.Message);
+                        }
+                }
+
+                musicCursor.Close();
+            }
+
+            albumCollection = new AlbumCollection(albumList);
+            songCollection = new SongCollection(songList);
+        }
+
+        private AlbumCollection PlatformGetAlbums()
+        {
+            return albumCollection;
+        }
+
+        private SongCollection PlatformGetSongs()
+        {
+            return songCollection;
+        }
+
+        private void PlatformDispose()
+        {
+
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/MediaLibrary.Default.cs b/MonoGame.Framework/Media/MediaLibrary.Default.cs
new file mode 100644
index 00000000000..9deaa9f59b9
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaLibrary.Default.cs
@@ -0,0 +1,31 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public partial class MediaLibrary
+    {
+        private void PlatformLoad(Action<int> progressCallback)
+        {
+            
+        }
+
+        private AlbumCollection PlatformGetAlbums()
+        {
+            return null;
+        }
+
+        private SongCollection PlatformGetSongs()
+        {
+            return null;
+        }
+
+        private void PlatformDispose()
+        {
+            
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Media/MediaLibrary.IOS.cs b/MonoGame.Framework/Media/MediaLibrary.IOS.cs
new file mode 100644
index 00000000000..5f92af30267
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaLibrary.IOS.cs
@@ -0,0 +1,95 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using Foundation;
+using MediaPlayer;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public partial class MediaLibrary
+    {
+        private static AlbumCollection albumCollection;
+        private static SongCollection songCollection;
+
+        private void PlatformLoad(Action<int> progressCallback)
+        {
+            var songList = new List<Song>();
+            var albumList = new List<Album>();
+
+            foreach (var collection in MPMediaQuery.AlbumsQuery.Collections)
+            {
+                var nsAlbumArtist = collection.RepresentativeItem.ValueForProperty(MPMediaItem.AlbumArtistProperty);
+                var nsAlbumName = collection.RepresentativeItem.ValueForProperty(MPMediaItem.AlbumTitleProperty);
+                var nsAlbumGenre = collection.RepresentativeItem.ValueForProperty(MPMediaItem.GenreProperty);
+                string albumArtist = nsAlbumArtist == null ? "Unknown Artist" : nsAlbumArtist.ToString();
+                string albumName = nsAlbumName == null ? "Unknown Album" : nsAlbumName.ToString();
+                string albumGenre = nsAlbumGenre == null ? "Unknown Genre" : nsAlbumGenre.ToString();
+                MPMediaItemArtwork thumbnail = collection.RepresentativeItem.ValueForProperty(MPMediaItem.ArtworkProperty) as MPMediaItemArtwork;
+
+                var albumSongs = new List<Song>((int)collection.Count);
+                var album = new Album(new SongCollection(albumSongs), albumName, new Artist(albumArtist), new Genre(albumGenre), thumbnail);
+                albumList.Add(album);
+
+                foreach (var item in collection.Items)
+                {
+                    var nsArtist = item.ValueForProperty(MPMediaItem.ArtistProperty);
+                    var nsTitle = item.ValueForProperty(MPMediaItem.TitleProperty);
+                    var nsGenre = item.ValueForProperty(MPMediaItem.GenreProperty);
+                    var assetUrl = item.ValueForProperty(MPMediaItem.AssetURLProperty) as NSUrl;
+
+                    if (nsTitle == null || assetUrl == null) // The Asset URL check will exclude iTunes match items from the Media Library that are not downloaded, but show up in the music app
+                        continue;
+
+                    string artist = nsArtist == null ? "Unknown Artist" : nsArtist.ToString();
+                    string title = nsTitle.ToString();
+                    string genre = nsGenre == null ? "Unknown Genre" : nsGenre.ToString();
+                    TimeSpan duration = TimeSpan.FromSeconds(((NSNumber)item.ValueForProperty(MPMediaItem.PlaybackDurationProperty)).FloatValue);
+
+                    var song = new Song(album, new Artist(artist), new Genre(genre), title, duration, item, assetUrl);
+                    albumSongs.Add(song);
+                    songList.Add(song);
+                }
+            }
+
+            albumCollection = new AlbumCollection(albumList);
+            songCollection = new SongCollection(songList);
+
+            /*_playLists = new PlaylistCollection();
+					
+			MPMediaQuery playlists = new MPMediaQuery();
+			playlists.GroupingType = MPMediaGrouping.Playlist;
+            for (int i = 0; i < playlists.Collections.Length; i++)
+            {
+                MPMediaItemCollection item = playlists.Collections[i];
+                Playlist list = new Playlist();
+                list.Name = playlists.Items[i].ValueForProperty(MPMediaPlaylistPropertyName).ToString();
+                for (int k = 0; k < item.Items.Length; k++)
+                {
+                    TimeSpan time = TimeSpan.Parse(item.Items[k].ValueForProperty(MPMediaItem.PlaybackDurationProperty).ToString());
+                    list.Duration += time;
+                }
+                _playLists.Add(list);
+            }*/
+        }
+
+        //private static readonly NSString MPMediaPlaylistPropertyName = new NSString(MPMediaPlaylistProperty.Name);
+
+        private AlbumCollection PlatformGetAlbums()
+        {
+            return albumCollection;
+        }
+
+        private SongCollection PlatformGetSongs()
+        {
+            return songCollection;
+        }
+
+        private void PlatformDispose()
+        {
+            
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/MediaLibrary.WinRT.cs b/MonoGame.Framework/Media/MediaLibrary.WinRT.cs
new file mode 100644
index 00000000000..58db9b30817
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaLibrary.WinRT.cs
@@ -0,0 +1,176 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Windows.Storage;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using Windows.Storage.FileProperties;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public partial class MediaLibrary
+    {
+        private const string CacheFile = "MediaLibrary.cache";
+
+        private static StorageFolder musicFolder;
+        private static AlbumCollection albumCollection;
+        private static SongCollection songCollection;
+
+        private void PlatformLoad(Action<int> progressCallback)
+        {
+            Task.Run(async () =>
+            {
+                if (musicFolder == null)
+                {
+                    try
+                    {
+                        musicFolder = KnownFolders.MusicLibrary;
+                    }
+                    catch (Exception e)
+                    {
+                        Debug.WriteLine("Failed to access Music Library: " + e.Message);
+                        albumCollection = new AlbumCollection(new List<Album>());
+                        songCollection = new SongCollection(new List<Song>());
+                        return;
+                    }
+                }
+                    
+            
+                var files = new List<StorageFile>();
+                await this.GetAllFiles(musicFolder, files);
+
+                var songList = new List<Song>();
+                var albumList = new List<Album>();
+
+                var artists = new Dictionary<string, Artist>();
+                var albums = new Dictionary<string, Album>();
+                var genres = new Dictionary<string, Genre>();
+
+                var cache = new Dictionary<string, MusicProperties>();
+
+                // Read cache
+                var cacheFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(CacheFile, CreationCollisionOption.OpenIfExists);
+                using (var baseStream = await cacheFile.OpenStreamForReadAsync())
+                using (var stream = new BinaryReader(baseStream))
+                    try
+                    {
+                        for (; baseStream.Position < baseStream.Length; )
+                        {
+                            var entry = MusicProperties.Deserialize(stream);
+                            cache.Add(entry.Path, entry);
+                        }
+                    }
+                    catch { }
+
+                // Write cache
+                cacheFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(CacheFile, CreationCollisionOption.ReplaceExisting);
+                using (var stream = new BinaryWriter(await cacheFile.OpenStreamForWriteAsync()))
+                {
+                    int prevProgress = 0;
+
+                    for (int i = 0; i < files.Count; i++)
+                    {
+                        var file = files[i];
+                        try
+                        {
+                            MusicProperties properties;
+                            if (!(cache.TryGetValue(file.Path, out properties) && properties.TryMatch(file)))
+                                properties = new MusicProperties(file);
+                            properties.Serialize(stream);
+
+                            if (string.IsNullOrWhiteSpace(properties.Title))
+                                continue;
+
+                            Artist artist;
+                            if (!artists.TryGetValue(properties.Artist, out artist))
+                            {
+                                artist = new Artist(properties.Artist);
+                                artists.Add(artist.Name, artist);
+                            }
+
+                            Artist albumArtist;
+                            if (!artists.TryGetValue(properties.AlbumArtist, out albumArtist))
+                            {
+                                albumArtist = new Artist(properties.AlbumArtist);
+                                artists.Add(albumArtist.Name, albumArtist);
+                            }
+
+                            Genre genre;
+                            if (!genres.TryGetValue(properties.Genre, out genre))
+                            {
+                                genre = new Genre(properties.Genre);
+                                genres.Add(genre.Name, genre);
+                            }
+
+                            Album album;
+                            if (!albums.TryGetValue(properties.Album, out album))
+                            {
+                                var thumbnail = Task.Run(async () => await properties.File.GetThumbnailAsync(ThumbnailMode.MusicView, 300, ThumbnailOptions.ResizeThumbnail)).Result;
+                                album = new Album(new SongCollection(), properties.Album, albumArtist, genre, thumbnail.Type == ThumbnailType.Image ? thumbnail : null);
+                                albums.Add(album.Name, album);
+                                albumList.Add(album);
+                            }
+
+                            var song = new Song(album, artist, genre, properties);
+                            song.Album.Songs.Add(song);
+                            songList.Add(song);
+                        }
+                        catch (Exception e)
+                        {
+                            Debug.WriteLine("MediaLibrary exception: " + e.Message);
+                        }
+
+                        int progress = 100 * i / files.Count;
+                        if (progress > prevProgress)
+                        {
+                            prevProgress = progress;
+                            if (progressCallback != null)
+                                progressCallback.Invoke(progress);
+                        }
+                    }
+                }
+
+                if (progressCallback != null)
+                    progressCallback.Invoke(100);
+
+                albumCollection = new AlbumCollection(albumList);
+                songCollection = new SongCollection(songList);
+            }).Wait();
+        }
+
+        private async Task GetAllFiles(StorageFolder storageFolder, List<StorageFile> musicFiles)
+        {
+            foreach (var item in await storageFolder.GetItemsAsync())
+                if (item is StorageFile)
+                {
+                    var file = item as StorageFile;
+                    if (file.ContentType.StartsWith("audio") && !file.ContentType.EndsWith("url"))
+                        musicFiles.Add(file);
+                }
+                else
+                {
+                    var folder = item as StorageFolder;
+                    await this.GetAllFiles(folder, musicFiles);
+                }
+        }
+
+        private AlbumCollection PlatformGetAlbums()
+        {
+            return albumCollection;
+        }
+
+        private SongCollection PlatformGetSongs()
+        {
+            return songCollection;
+        }
+
+        private void PlatformDispose()
+        {
+            
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Media/MediaLibrary.cs b/MonoGame.Framework/Media/MediaLibrary.cs
new file mode 100644
index 00000000000..a0a0a522c21
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaLibrary.cs
@@ -0,0 +1,44 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Media
+{
+	public partial class MediaLibrary : IDisposable
+	{
+        public AlbumCollection Albums { get { return PlatformGetAlbums();  } }
+        //public ArtistCollection Artists { get; private set; }
+        //public GenreCollection Genres { get; private set; }
+        public bool IsDisposed { get; private set; }
+        public MediaSource MediaSource { get { return null; } }
+		//public PlaylistCollection Playlists { get; private set; }
+        public SongCollection Songs { get { return PlatformGetSongs(); } }
+
+		public MediaLibrary()
+		{
+		}
+
+        /// <summary>
+        /// Load the contents of MediaLibrary. This blocking call might take up to a few minutes depending on the platform and the size of the user's music library.
+        /// </summary>
+        /// <param name="progressCallback">Callback that reports back the progress of the music library loading in percents (0-100).</param>
+        public void Load(Action<int> progressCallback = null)
+	    {
+	        PlatformLoad(progressCallback);
+	    }
+		
+		public MediaLibrary(MediaSource mediaSource)
+		{
+            throw new NotSupportedException("Initializing from MediaSource is not supported");
+		}
+		
+		public void Dispose()
+		{
+		    PlatformDispose();
+		    this.IsDisposed = true;
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Media/MediaManagerState.cs b/MonoGame.Framework/Media/MediaManagerState.cs
new file mode 100644
index 00000000000..0c4421b6fc4
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaManagerState.cs
@@ -0,0 +1,41 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using SharpDX.MediaFoundation;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    /// <summary>
+    /// This class provides a way for the MediaManager to be initialised exactly once, 
+    /// regardless of how many different places need it, and which is called first.
+    /// </summary>
+    internal sealed class MediaManagerState
+    {
+        private static bool started;
+
+        /// <summary>
+        /// Ensures that the MediaManager has been initialised. Must be called from UI thread.
+        /// </summary>
+        public static void CheckStartup()
+        {
+            if(!started)
+            {
+                started = true;
+                MediaManager.Startup(true);
+            }
+        }
+
+        /// <summary>
+        /// Ensures that the MediaManager has been shutdown. Must be called from UI thread.
+        /// </summary>
+        public static void CheckShutdown()
+        {
+            if(started)
+            {
+                started = false;
+                MediaManager.Shutdown();
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/MediaPlayer.Default.cs b/MonoGame.Framework/Media/MediaPlayer.Default.cs
new file mode 100644
index 00000000000..79e0542b26b
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaPlayer.Default.cs
@@ -0,0 +1,142 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+#if IOS
+using AudioToolbox;
+using AVFoundation;
+#endif
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public static partial class MediaPlayer
+    {
+
+        #region Properties
+        
+        private static void PlatformInitialize()
+        {
+
+        }
+
+        private static bool PlatformGetIsMuted()
+        {
+            return _isMuted;
+        }
+
+        private static void PlatformSetIsMuted(bool muted)
+        {
+            _isMuted = muted;
+
+            if (_queue.Count == 0)
+                return;
+
+            var newVolume = _isMuted ? 0.0f : _volume;
+            _queue.SetVolume(newVolume);
+        }
+
+        private static bool PlatformGetIsRepeating()
+        {
+            return _isRepeating;
+        }
+
+        private static void PlatformSetIsRepeating(bool repeating)
+        {
+            _isRepeating = repeating;
+        }
+
+        private static bool PlatformGetIsShuffled()
+        {
+            return _isShuffled;
+        }
+
+        private static void PlatformSetIsShuffled(bool shuffled)
+        {
+            _isShuffled = shuffled;
+        }
+
+        private static TimeSpan PlatformGetPlayPosition()
+        {
+            if (_queue.ActiveSong == null)
+                return TimeSpan.Zero;
+
+            return _queue.ActiveSong.Position;
+        }
+
+#if (IOS && !TVOS) || ANDROID
+        private static void PlatformSetPlayPosition(TimeSpan playPosition)
+        {
+            if (_queue.ActiveSong != null)
+                _queue.ActiveSong.Position = playPosition;
+        }
+#endif
+
+        private static MediaState PlatformGetState()
+        {
+            return _state;
+        }
+
+        private static float PlatformGetVolume()
+        {
+            return _volume;
+        }
+
+        private static void PlatformSetVolume(float volume)
+        {
+            _volume = volume;
+
+            if (_queue.ActiveSong == null)
+                return;
+
+            _queue.SetVolume(_isMuted ? 0.0f : _volume);
+        }
+
+        private static bool PlatformGetGameHasControl()
+        {
+#if IOS
+            return !AVAudioSession.SharedInstance().OtherAudioPlaying;
+#else
+            // TODO: Fix me!
+            return true;
+#endif
+        }
+		#endregion
+
+        private static void PlatformPause()
+        {
+            if (_queue.ActiveSong == null)
+                return;
+
+            _queue.ActiveSong.Pause();
+        }
+
+        private static void PlatformPlaySong(Song song, TimeSpan? startPosition)
+        {
+            if (_queue.ActiveSong == null)
+                return;
+
+            song.SetEventHandler(OnSongFinishedPlaying);
+
+            song.Volume = _isMuted ? 0.0f : _volume;
+            song.Play(startPosition);
+        }
+
+        private static void PlatformResume()
+        {
+            if (_queue.ActiveSong == null)
+                return;
+
+            _queue.ActiveSong.Resume();
+        }
+
+        private static void PlatformStop()
+        {
+            // Loop through so that we reset the PlayCount as well
+            foreach (var song in Queue.Songs)
+                _queue.ActiveSong.Stop();
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Media/MediaPlayer.WME.cs b/MonoGame.Framework/Media/MediaPlayer.WME.cs
new file mode 100644
index 00000000000..c26dfadee8e
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaPlayer.WME.cs
@@ -0,0 +1,154 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using SharpDX.MediaFoundation;
+using SharpDX.Multimedia;
+using Windows.UI.Core;
+using Windows.ApplicationModel.Core;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public static partial class MediaPlayer
+    {
+        // RAYB: This needs to be turned back into a readonly.
+        private static MediaEngine _mediaEngineEx;
+        private static CoreDispatcher _dispatcher;
+
+        private enum SessionState { Stopped, Started, Paused }
+        private static SessionState _sessionState = SessionState.Stopped;
+        private static TimeSpan? _desiredPosition;
+
+        private static void PlatformInitialize()
+        {
+            MediaManager.Startup(true);
+            using (var factory = new MediaEngineClassFactory())
+            using (var attributes = new MediaEngineAttributes { AudioCategory = AudioStreamCategory.GameMedia })
+            {
+                var creationFlags = MediaEngineCreateFlags.AudioOnly;
+
+                var mediaEngine = new MediaEngine(factory, attributes, creationFlags, MediaEngineExOnPlaybackEvent);
+                _mediaEngineEx = mediaEngine.QueryInterface<MediaEngineEx>();
+            }
+
+
+            _dispatcher = CoreApplication.MainView.CoreWindow.Dispatcher;
+        }
+
+        private static void MediaEngineExOnPlaybackEvent(MediaEngineEvent mediaEvent, long param1, int param2)
+        {
+            if (mediaEvent == MediaEngineEvent.LoadedData)
+            {
+                if (_desiredPosition.HasValue)
+                    _mediaEngineEx.CurrentTime = _desiredPosition.Value.TotalSeconds;
+                if (_sessionState == SessionState.Started)
+                    _mediaEngineEx.Play();
+            }
+            if (mediaEvent == MediaEngineEvent.Ended)
+            {
+                _sessionState = SessionState.Stopped;
+                _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => OnSongFinishedPlaying(null, null)).AsTask();
+            }
+        }
+
+        #region Properties
+
+        private static bool PlatformGetIsMuted()
+        {
+            return _isMuted;
+        }
+
+        private static void PlatformSetIsMuted(bool muted)
+        {
+            _isMuted = muted;
+
+            _mediaEngineEx.Muted = _isMuted;
+        }
+
+        private static bool PlatformGetIsRepeating()
+        {
+            return _isRepeating;
+        }
+
+        private static void PlatformSetIsRepeating(bool repeating)
+        {
+            _isRepeating = repeating;
+
+            _mediaEngineEx.Loop = _isRepeating;
+        }
+
+        private static bool PlatformGetIsShuffled()
+        {
+            return _isShuffled;
+        }
+
+        private static void PlatformSetIsShuffled(bool shuffled)
+        {
+            _isShuffled = shuffled;
+        }
+
+        private static TimeSpan PlatformGetPlayPosition()
+        {
+            return TimeSpan.FromSeconds(_mediaEngineEx.CurrentTime);
+        }
+
+        private static bool PlatformGetGameHasControl()
+        {
+            // TODO: Fix me!
+            return true;
+        }
+
+        private static MediaState PlatformGetState()
+        {
+            return _state;
+        }
+
+        private static float PlatformGetVolume()
+        {
+            return _volume;
+        }
+
+        private static void PlatformSetVolume(float volume)
+        {
+            _volume = volume;
+
+            _mediaEngineEx.Volume = _volume;
+        }
+
+        #endregion
+
+        private static void PlatformPause()
+        {
+            if (_sessionState != SessionState.Started)
+                return;
+            _sessionState = SessionState.Paused;
+            _mediaEngineEx.Pause();
+        }
+
+        private static void PlatformPlaySong(Song song, TimeSpan? startPosition)
+        {
+            _mediaEngineEx.Source = song.FilePath;
+            _mediaEngineEx.Load();
+            _desiredPosition = startPosition;
+            _sessionState = SessionState.Started;
+
+            //We start playing when we get a LoadedData event in MediaEngineExOnPlaybackEvent
+        }
+
+        private static void PlatformResume()
+        {
+            if (_sessionState != SessionState.Paused)
+                return;
+            _mediaEngineEx.Play();
+        }
+
+        private static void PlatformStop()
+        {
+            if (_sessionState == SessionState.Stopped)
+                return;
+            _mediaEngineEx.Source = null;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Media/MediaPlayer.WMS.cs b/MonoGame.Framework/Media/MediaPlayer.WMS.cs
new file mode 100644
index 00000000000..000162ea870
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaPlayer.WMS.cs
@@ -0,0 +1,303 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using SharpDX;
+using SharpDX.MediaFoundation;
+using SharpDX.Win32;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public static partial class MediaPlayer
+    {
+        private static MediaSession _session;
+        private static AudioStreamVolume _volumeController;
+        private static readonly object _volumeLock = new object();
+        private static PresentationClock _clock;
+
+        private static Song _nextSong;
+        private static TimeSpan? _nextSongStartPosition;
+        private static Variant? _desiredPosition;
+
+
+        private static Song _currentSong;
+
+        private enum SessionState { Stopped, Stopping, Started, Paused, Ended }
+        private static SessionState _sessionState = SessionState.Stopped;
+
+        private static Guid AudioStreamVolumeGuid;
+
+        private static readonly Variant PositionCurrent = new Variant();
+        private static readonly Variant PositionBeginning = new Variant { ElementType = VariantElementType.Long, Value = 0L };
+
+        private static Callback _callback;
+
+        private class Callback : IAsyncCallback
+        {
+            public void Dispose()
+            {
+            }
+
+            public IDisposable Shadow { get; set; }
+            public void Invoke(AsyncResult asyncResultRef)
+            {
+                var ev = _session.EndGetEvent(asyncResultRef);
+
+                switch (ev.TypeInfo)
+                {
+                    case MediaEventTypes.SessionEnded:
+                        _sessionState = SessionState.Ended;
+                        OnSongFinishedPlaying(null, null);
+                        break;
+                    case MediaEventTypes.SessionTopologyStatus:
+                        if (ev.Get(EventAttributeKeys.TopologyStatus) == TopologyStatus.Ready)
+                            OnTopologyReady();
+                        break;
+                    case MediaEventTypes.SessionStopped:
+                        OnSessionStopped();
+                        break;
+                }
+
+                _session.BeginGetEvent(this, null);
+            }
+
+            public AsyncCallbackFlags Flags { get; private set; }
+            public WorkQueueId WorkQueueId { get; private set; }
+        }
+
+        private static void PlatformInitialize()
+        {
+            // The GUID is specified in a GuidAttribute attached to the class
+            AudioStreamVolumeGuid = Guid.Parse(((GuidAttribute)typeof(AudioStreamVolume).GetCustomAttributes(typeof(GuidAttribute), false)[0]).Value);
+
+            MediaManagerState.CheckStartup();
+            MediaFactory.CreateMediaSession(null, out _session);
+
+            _callback = new Callback();
+            _session.BeginGetEvent(_callback, null);
+
+            _clock = _session.Clock.QueryInterface<PresentationClock>();
+        }
+
+        #region Properties
+
+        private static bool PlatformGetIsMuted()
+        {
+            return _isMuted;
+        }
+
+        private static void PlatformSetIsMuted(bool muted)
+        {
+            _isMuted = muted;
+
+            SetChannelVolumes();
+        }
+
+        private static bool PlatformGetIsRepeating()
+        {
+            return _isRepeating;
+        }
+
+        private static void PlatformSetIsRepeating(bool repeating)
+        {
+            _isRepeating = repeating;
+        }
+
+        private static bool PlatformGetIsShuffled()
+        {
+            return _isShuffled;
+        }
+
+        private static void PlatformSetIsShuffled(bool shuffled)
+        {
+            _isShuffled = shuffled;
+        }
+
+        private static TimeSpan PlatformGetPlayPosition()
+        {
+            if ((_sessionState == SessionState.Stopped) || (_sessionState == SessionState.Stopping))
+                return TimeSpan.Zero;
+            try
+            {
+                return TimeSpan.FromTicks(_clock.Time);
+            }
+            catch (SharpDXException)
+            {
+                // The presentation clock is most likely not quite ready yet
+                return TimeSpan.Zero;
+            }
+        }
+
+        private static bool PlatformGetGameHasControl()
+        {
+            // TODO: Fix me!
+            return true;
+        }
+
+        private static MediaState PlatformGetState()
+        {
+            return _state;
+        }
+
+        private static float PlatformGetVolume()
+        {
+            return _volume;
+        }
+
+        private static void SetChannelVolumes()
+        {
+            lock (_volumeLock)
+            {
+                if (_volumeController == null)
+                    return;
+
+                float volume = _isMuted ? 0f : _volume;
+                for (int i = 0; i < _volumeController.ChannelCount; i++)
+                    _volumeController.SetChannelVolume(i, volume);
+            }
+        }
+
+        private static void PlatformSetVolume(float volume)
+        {
+            _volume = volume;
+            SetChannelVolumes();
+        }
+
+        #endregion
+
+        private static void PlatformPause()
+        {
+            if (_sessionState != SessionState.Started)
+                return;
+            _sessionState = SessionState.Paused;
+            _session.Pause();
+        }
+
+        private static void PlatformPlaySong(Song song, TimeSpan? startPosition)
+        {
+            if (_currentSong == song)
+                ReplayCurrentSong(song, startPosition);
+            else
+                PlayNewSong(song, startPosition);
+        }
+
+        private static void ReplayCurrentSong(Song song, TimeSpan? startPosition)
+        {
+            if (_sessionState == SessionState.Stopping)
+            {
+                // The song will be started after the SessionStopped event is received
+                _nextSong = song;
+                _nextSongStartPosition = startPosition;
+                return;
+            }
+
+            StartSession(PositionVariantFor(startPosition));
+        }
+
+        private static void PlayNewSong(Song song, TimeSpan? startPosition)
+        {
+            if (_sessionState != SessionState.Stopped)
+            {
+                // The session needs to be stopped to reset the play position
+                // The new song will be started after the SessionStopped event is received
+                _nextSong = song;
+                _nextSongStartPosition = startPosition;
+                PlatformStop();
+                return;
+            }
+
+            StartNewSong(song, startPosition);
+        }
+
+        private static void StartNewSong(Song song, TimeSpan? startPosition)
+        {
+            lock (_volumeLock)
+            {
+                if (_volumeController != null)
+                {
+                    _volumeController.Dispose();
+                    _volumeController = null;
+                }
+            }
+
+            _currentSong = song;
+
+            //We need to start playing from 0, then seek the stream when the topology is ready, otherwise the song doesn't play.
+            if (startPosition.HasValue)
+                _desiredPosition = PositionVariantFor(startPosition.Value);
+            _session.SetTopology(SessionSetTopologyFlags.Immediate, song.Topology);
+
+            StartSession(PositionBeginning);
+
+            // The volume service won't be available until the session topology
+            // is ready, so we now need to wait for the event indicating this
+        }
+
+        private static void StartSession(Variant startPosition)
+        {
+            _sessionState = SessionState.Started;
+            _session.Start(null, startPosition);
+        }
+
+        private static void OnTopologyReady()
+        {
+            lock (_volumeLock)
+            {
+                IntPtr volumeObjectPtr;
+                MediaFactory.GetService(_session, MediaServiceKeys.StreamVolume, AudioStreamVolumeGuid, out volumeObjectPtr);
+                _volumeController = CppObject.FromPointer<AudioStreamVolume>(volumeObjectPtr);
+            }
+
+            SetChannelVolumes();
+
+            if (_desiredPosition.HasValue)
+            {
+                StartSession(_desiredPosition.Value);
+                _desiredPosition = null;
+            }
+        }
+
+        private static void PlatformResume()
+        {
+            if (_sessionState != SessionState.Paused)
+                return;
+            StartSession(PositionCurrent);
+        }
+
+        private static void PlatformStop()
+        {
+            if ((_sessionState == SessionState.Stopped) || (_sessionState == SessionState.Stopping))
+                return;
+            bool hasFinishedPlaying = (_sessionState == SessionState.Ended);
+            _sessionState = SessionState.Stopping;
+            if (hasFinishedPlaying)
+            {
+                // The play position needs to be reset before stopping otherwise the next song may not start playing
+                _session.Start(null, PositionBeginning);
+            }
+            _session.Stop();
+        }
+
+        private static void OnSessionStopped()
+        {
+            _sessionState = SessionState.Stopped;
+            if (_nextSong != null)
+            {
+                if (_nextSong != _currentSong)
+                    StartNewSong(_nextSong, _nextSongStartPosition);
+                else
+                    StartSession(PositionVariantFor(_nextSongStartPosition));
+                _nextSong = null;
+            }
+        }
+
+        private static Variant PositionVariantFor(TimeSpan? position)
+        {
+            if (position.HasValue)
+                return new Variant { Value = position.Value.Ticks };
+            return PositionBeginning;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/MediaPlayer.cs b/MonoGame.Framework/Media/MediaPlayer.cs
new file mode 100644
index 00000000000..7821f6731f1
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaPlayer.cs
@@ -0,0 +1,226 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public static partial class MediaPlayer
+    {
+		// Need to hold onto this to keep track of how many songs
+		// have played when in shuffle mode
+		private static int _numSongsInQueuePlayed = 0;
+		private static MediaState _state = MediaState.Stopped;
+		private static float _volume = 1.0f;
+		private static bool _isMuted;
+        private static bool _isRepeating;
+        private static bool _isShuffled;
+		private static readonly MediaQueue _queue = new MediaQueue();
+
+		public static event EventHandler<EventArgs> ActiveSongChanged;
+        public static event EventHandler<EventArgs> MediaStateChanged;
+
+        static MediaPlayer()
+        {
+            PlatformInitialize();
+        }
+
+        #region Properties
+
+        public static MediaQueue Queue { get { return _queue; } }
+		
+		public static bool IsMuted
+        {
+            get { return PlatformGetIsMuted(); }
+            set { PlatformSetIsMuted(value); }
+        }
+
+        public static bool IsRepeating 
+        {
+            get { return PlatformGetIsRepeating(); }
+            set { PlatformSetIsRepeating(value); }
+        }
+
+        public static bool IsShuffled
+        {
+            get { return PlatformGetIsShuffled(); }
+            set { PlatformSetIsShuffled(value); }
+        }
+
+        public static bool IsVisualizationEnabled { get { return false; } }
+
+        public static TimeSpan PlayPosition
+        {
+            get { return PlatformGetPlayPosition(); }
+#if (IOS && !TVOS) || ANDROID
+            set { PlatformSetPlayPosition(value); }
+#endif
+        }
+
+        public static MediaState State
+        {
+            get { return PlatformGetState(); }
+            private set
+            {
+                if (_state != value)
+                {
+                    _state = value;
+                    EventHelpers.Raise(null, MediaStateChanged, EventArgs.Empty);
+                }
+            }
+        }
+
+        public static bool GameHasControl
+        {
+            get
+            {
+                return PlatformGetGameHasControl();
+            }
+        }
+		
+
+        public static float Volume
+        {
+            get { return PlatformGetVolume(); }
+            set
+            {
+                var volume = MathHelper.Clamp(value, 0, 1);
+
+                PlatformSetVolume(volume);
+            }
+        }
+
+		#endregion
+		
+        public static void Pause()
+        {
+            if (State != MediaState.Playing || _queue.ActiveSong == null)
+                return;
+
+            PlatformPause();
+
+            State = MediaState.Paused;
+        }
+
+        /// <summary>
+        /// Play clears the current playback queue, and then queues up the specified song for playback. 
+        /// Playback starts immediately at the beginning of the song.
+        /// </summary>
+        public static void Play(Song song)
+        {
+            Play(song, null);
+        }
+
+        /// <summary>
+        /// Play clears the current playback queue, and then queues up the specified song for playback. 
+        /// Playback starts immediately at the given position of the song.
+        /// </summary>
+        public static void Play(Song song, TimeSpan? startPosition)
+        {
+            var previousSong = _queue.Count > 0 ? _queue[0] : null;
+            _queue.Clear();
+            _numSongsInQueuePlayed = 0;
+            _queue.Add(song);
+            _queue.ActiveSongIndex = 0;
+            
+            PlaySong(song, startPosition);
+
+            if (previousSong != song)
+                EventHelpers.Raise(null, ActiveSongChanged, EventArgs.Empty);
+        }
+
+		public static void Play(SongCollection collection, int index = 0)
+		{
+            _queue.Clear();
+            _numSongsInQueuePlayed = 0;
+
+			foreach(var song in collection)
+				_queue.Add(song);
+			
+			_queue.ActiveSongIndex = index;
+			
+			PlaySong(_queue.ActiveSong, null);
+		}
+
+        private static void PlaySong(Song song, TimeSpan? startPosition)
+        {
+            if (song != null && song.IsDisposed)
+                throw new ObjectDisposedException("song");
+
+            PlatformPlaySong(song, startPosition);
+            State = MediaState.Playing;
+        }
+
+        internal static void OnSongFinishedPlaying(object sender, EventArgs args)
+		{
+			// TODO: Check args to see if song sucessfully played
+			_numSongsInQueuePlayed++;
+			
+			if (_numSongsInQueuePlayed >= _queue.Count)
+			{
+				_numSongsInQueuePlayed = 0;
+				if (!IsRepeating)
+				{
+					Stop();
+					EventHelpers.Raise(null, ActiveSongChanged, EventArgs.Empty);
+					return;
+				}
+			}
+
+			MoveNext();
+		}
+
+        public static void Resume()
+        {
+            if (State != MediaState.Paused)
+                return;
+
+            PlatformResume();
+			State = MediaState.Playing;
+        }
+
+        public static void Stop()
+        {
+            if (State == MediaState.Stopped)
+                return;
+
+            PlatformStop();
+			State = MediaState.Stopped;
+		}
+		
+		public static void MoveNext()
+		{
+			NextSong(1);
+		}
+		
+		public static void MovePrevious()
+		{
+			NextSong(-1);
+		}
+		
+		private static void NextSong(int direction)
+		{
+            Stop();
+
+            if (IsRepeating && _queue.ActiveSongIndex >= _queue.Count - 1)
+            {
+                _queue.ActiveSongIndex = 0;
+                
+                // Setting direction to 0 will force the first song
+                // in the queue to be played.
+                // if we're on "shuffle", then it'll pick a random one
+                // anyway, regardless of the "direction".
+                direction = 0;
+            }
+
+			var nextSong = _queue.GetNextSong(direction, IsShuffled);
+
+            if (nextSong != null)
+                PlaySong(nextSong, null);
+
+            EventHelpers.Raise(null, ActiveSongChanged, EventArgs.Empty);
+		}
+    }
+}
+
diff --git a/MonoGame.Framework/Media/MediaQueue.cs b/MonoGame.Framework/Media/MediaQueue.cs
new file mode 100644
index 00000000000..cca3b3f2213
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaQueue.cs
@@ -0,0 +1,115 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Media
+{
+	public sealed class MediaQueue
+	{
+        List<Song> songs = new List<Song>();
+		private int _activeSongIndex = -1;
+		private Random random = new Random();
+
+		public MediaQueue()
+		{
+			
+		}
+		
+		public Song ActiveSong
+		{
+			get
+			{
+				if (songs.Count == 0 || _activeSongIndex < 0)
+					return null;
+				
+				return songs[_activeSongIndex];
+			}
+		}
+		
+		public int ActiveSongIndex
+		{
+		    get
+		    {
+		        return _activeSongIndex;
+		    }
+		    set
+		    {
+		        _activeSongIndex = value;
+		    }
+		}
+
+        internal int Count
+        {
+            get
+            {
+                return songs.Count;
+            }
+        }
+
+        public Song this[int index]
+        {
+            get
+            {
+                return songs[index];
+            }
+        }
+
+        internal IEnumerable<Song> Songs
+        {
+            get
+            {
+                return songs;
+            }
+        }
+
+		internal Song GetNextSong(int direction, bool shuffle)
+		{
+			if (shuffle)
+				_activeSongIndex = random.Next(songs.Count);
+			else			
+				_activeSongIndex = (int)MathHelper.Clamp(_activeSongIndex + direction, 0, songs.Count - 1);
+			
+			return songs[_activeSongIndex];
+		}
+		
+		internal void Clear()
+		{
+			Song song;
+			for(; songs.Count > 0; )
+			{
+				song = songs[0];
+#if !DIRECTX
+				song.Stop();
+#endif
+				songs.Remove(song);
+			}	
+		}
+
+#if !DIRECTX
+        internal void SetVolume(float volume)
+        {
+            int count = songs.Count;
+            for (int i = 0; i < count; ++i)
+                songs[i].Volume = volume;
+        }
+#endif
+
+        internal void Add(Song song)
+        {
+            songs.Add(song);
+        }
+
+#if !DIRECTX
+        internal void Stop()
+        {
+            int count = songs.Count;
+            for (int i = 0; i < count; ++i)
+                songs[i].Stop();
+        }
+#endif
+	}
+}
+
diff --git a/MonoGame.Framework/Media/MediaSource.cs b/MonoGame.Framework/Media/MediaSource.cs
new file mode 100644
index 00000000000..0886d83eb27
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaSource.cs
@@ -0,0 +1,49 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+#if IOS
+using UIKit;
+#endif
+
+namespace Microsoft.Xna.Framework.Media
+{
+	public sealed class MediaSource
+    {
+		private MediaSourceType _type;
+		private string _name;
+		internal MediaSource (string name, MediaSourceType type)
+		{
+			_name = name;
+			_type = type;
+		}
+				
+        public Microsoft.Xna.Framework.Media.MediaSourceType MediaSourceType
+        {
+            get
+            {
+				return _type;
+            }
+        }
+
+        public string Name
+        {
+            get
+            {
+				return _name;
+            }
+        }
+	
+		public static IList<MediaSource> GetAvailableMediaSources()
+        {
+#if IOS
+			MediaSource[] result = { new MediaSource(UIDevice.CurrentDevice.SystemName, MediaSourceType.LocalDevice) };
+#else
+			MediaSource[] result = { new MediaSource("DummpMediaSource", MediaSourceType.LocalDevice) };
+#endif
+			return result;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/MediaSourceType.cs b/MonoGame.Framework/Media/MediaSourceType.cs
new file mode 100644
index 00000000000..a190f850af8
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaSourceType.cs
@@ -0,0 +1,14 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Media
+{
+ 	public enum MediaSourceType
+    {
+        LocalDevice = 0,
+        WindowsMediaConnect = 4
+    }
+}
diff --git a/MonoGame.Framework/Media/MediaState.cs b/MonoGame.Framework/Media/MediaState.cs
new file mode 100644
index 00000000000..97f79248b5f
--- /dev/null
+++ b/MonoGame.Framework/Media/MediaState.cs
@@ -0,0 +1,16 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public enum MediaState
+    {
+        Stopped,
+        Playing,
+        Paused
+    }
+}
+
diff --git a/MonoGame.Framework/Media/MusicProperties.cs b/MonoGame.Framework/Media/MusicProperties.cs
new file mode 100644
index 00000000000..e309bff52b2
--- /dev/null
+++ b/MonoGame.Framework/Media/MusicProperties.cs
@@ -0,0 +1,108 @@
+#if WINDOWS_UAP
+
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Windows.Storage;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    class MusicProperties
+    {
+        public StorageFile File { get; private set; }
+        public string Path { get; private set; }
+        public DateTimeOffset DateCreated { get; private set; }
+
+        public string Album { get; private set; }
+        public string AlbumArtist { get; private set; }
+        public string Artist { get; private set; }
+        public TimeSpan Duration { get; private set; }
+        public string Genre { get; private set; }
+        public bool IsProtected { get; private set; }
+        public int Rating { get; private set; }
+        public string Title { get; private set; }
+        public int TrackNumber { get; private set; }
+
+        private MusicProperties() { }
+
+        public MusicProperties(StorageFile file)
+        {
+            this.File = file;
+            this.Path = this.File.Path;
+            this.DateCreated = this.File.DateCreated;
+
+            var properties = Task.Run(async () => await file.Properties.RetrievePropertiesAsync(new String[]
+                {
+                    "System.Music.AlbumTitle",
+                    "System.Music.AlbumArtist",
+                    "System.Music.Artist",
+                    "System.Media.Duration",
+                    "System.Music.Genre",
+                    "System.DRM.IsProtected",
+                    "System.Rating",
+                    "System.Title",
+                    "System.Music.TrackNumber"
+                })).Result;
+
+            object property;
+            this.Album = (properties.TryGetValue("System.Music.AlbumTitle", out property) ? (string)property : (string)null) ?? "";
+            this.Artist = (properties.TryGetValue("System.Music.Artist", out property) ? ((string[])property)[0] : (string)null) ?? "Unknown Artist";
+            this.AlbumArtist = (properties.TryGetValue("System.Music.AlbumArtist", out property) ? (string)property : (string)null) ?? this.Artist;
+            this.Duration = properties.TryGetValue("System.Media.Duration", out property) ? new TimeSpan((long)(ulong)property) : TimeSpan.Zero;
+            this.Genre = (properties.TryGetValue("System.Music.Genre", out property) ? ((string[])property)[0] : (string)null) ?? "";
+            this.IsProtected = properties.TryGetValue("System.DRM.IsProtected", out property) ? (bool)property : false;
+            this.Rating = properties.TryGetValue("System.Rating", out property) ? (int)(uint)property : 0;
+            this.Title = (properties.TryGetValue("System.Title", out property) ? (string)property : (string)null) ?? "";
+            this.TrackNumber = properties.TryGetValue("System.Music.TrackNumber", out property) ? (int)(uint)property : 0;
+        }
+
+        public bool TryMatch(StorageFile file)
+        {
+            if (file != null && file.Path == this.Path && file.DateCreated == this.DateCreated)
+            {
+                this.File = file;
+                return true;
+            }
+
+            return false;
+        }
+
+        public static MusicProperties Deserialize(BinaryReader stream)
+        {
+            var instance = new MusicProperties();
+            instance.Path = stream.ReadString();
+            instance.DateCreated = new DateTimeOffset(stream.ReadInt64(), new TimeSpan(stream.ReadInt64()));
+
+            instance.Album = stream.ReadString();
+            instance.AlbumArtist = stream.ReadString();
+            instance.Artist = stream.ReadString();
+            instance.Duration = new TimeSpan(stream.ReadInt64());
+            instance.Genre = stream.ReadString();
+            instance.IsProtected = stream.ReadBoolean();
+            instance.Rating = stream.ReadInt32();
+            instance.Title = stream.ReadString();
+            instance.TrackNumber = stream.ReadInt32();
+
+            return instance;
+        }
+
+        public void Serialize(BinaryWriter stream)
+        {
+            stream.Write(this.Path);
+            stream.Write(this.DateCreated.Ticks);
+            stream.Write(this.DateCreated.Offset.Ticks);
+
+            stream.Write(this.Album);
+            stream.Write(this.AlbumArtist);
+            stream.Write(this.Artist);
+            stream.Write(this.Duration.Ticks);
+            stream.Write(this.Genre);
+            stream.Write(this.IsProtected);
+            stream.Write(this.Rating);
+            stream.Write(this.Title);
+            stream.Write(this.TrackNumber);
+        }
+    }
+}
+
+#endif
diff --git a/MonoGame.Framework/Media/Playlist.cs b/MonoGame.Framework/Media/Playlist.cs
new file mode 100644
index 00000000000..1e9a5c578eb
--- /dev/null
+++ b/MonoGame.Framework/Media/Playlist.cs
@@ -0,0 +1,36 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed class Playlist : IDisposable
+    {
+        public TimeSpan Duration
+        {
+            get;
+			internal set;
+        }
+
+        public string Name
+        {
+            get;
+			internal set;
+        }
+
+		public void Dispose()
+        {
+        }
+
+		
+        /*public SongCollection Songs
+        {
+            get
+            {
+            }
+        }*/
+    }
+}
+
diff --git a/MonoGame.Framework/Media/PlaylistCollection.cs b/MonoGame.Framework/Media/PlaylistCollection.cs
new file mode 100644
index 00000000000..8e9e238369e
--- /dev/null
+++ b/MonoGame.Framework/Media/PlaylistCollection.cs
@@ -0,0 +1,109 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Media
+{
+
+    public sealed class PlaylistCollection : ICollection<Playlist>, IEnumerable<Playlist>, IEnumerable, IDisposable
+    {
+		private bool isReadOnly = false;
+		private List<Playlist> innerlist = new List<Playlist>();
+		
+        public void Dispose()
+        {
+        }
+
+        public IEnumerator<Playlist> GetEnumerator()
+        {
+            return innerlist.GetEnumerator();
+        }
+		
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return innerlist.GetEnumerator();
+        }
+
+        public int Count
+        {
+            get
+            {
+				return innerlist.Count;
+            }
+        }
+		
+		public bool IsReadOnly
+        {
+            get { return this.isReadOnly; }
+        }
+
+        public Playlist this[int index]
+        {
+            get
+            {
+				return this.innerlist[index];
+            }
+        }
+		
+		public void Add(Playlist item)
+        {
+            if (item == null)
+                throw new ArgumentNullException();
+
+            if (innerlist.Count == 0)
+            {
+                this.innerlist.Add(item);
+                return;
+            }
+
+            for (int i = 0; i < this.innerlist.Count; i++)
+            {
+                if (item.Duration < this.innerlist[i].Duration)
+                {
+                    this.innerlist.Insert(i, item);
+                    return;
+                }
+            }
+
+            this.innerlist.Add(item);
+        }
+		
+		public void Clear()
+        {
+            innerlist.Clear();
+        }
+        
+        public PlaylistCollection Clone()
+        {
+            PlaylistCollection plc = new PlaylistCollection();
+            foreach (Playlist playlist in this.innerlist)
+                plc.Add(playlist);
+            return plc;
+        }
+        
+        public bool Contains(Playlist item)
+        {
+            return innerlist.Contains(item);
+        }
+        
+        public void CopyTo(Playlist[] array, int arrayIndex)
+        {
+            innerlist.CopyTo(array, arrayIndex);
+        }
+		
+		public int IndexOf(Playlist item)
+        {
+            return innerlist.IndexOf(item);
+        }
+        
+        public bool Remove(Playlist item)
+        {
+            return innerlist.Remove(item);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Media/Song.Android.cs b/MonoGame.Framework/Media/Song.Android.cs
new file mode 100644
index 00000000000..12ddcc67ba9
--- /dev/null
+++ b/MonoGame.Framework/Media/Song.Android.cs
@@ -0,0 +1,201 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class Song : IEquatable<Song>, IDisposable
+    {
+        static Android.Media.MediaPlayer _androidPlayer;
+        static Song _playingSong;
+
+        private Album album;
+        private Artist artist;
+        private Genre genre;
+        private string name;
+        private TimeSpan duration;
+        private TimeSpan position;
+        private Android.Net.Uri assetUri;
+
+        [CLSCompliant(false)]
+        public Android.Net.Uri AssetUri
+        {
+            get { return this.assetUri; }
+        }
+
+        static Song()
+        {
+            _androidPlayer = new Android.Media.MediaPlayer();
+            _androidPlayer.Completion += AndroidPlayer_Completion;
+        }
+
+        internal Song(Album album, Artist artist, Genre genre, string name, TimeSpan duration, Android.Net.Uri assetUri)
+        {
+            this.album = album;
+            this.artist = artist;
+            this.genre = genre;
+            this.name = name;
+            this.duration = duration;
+            this.assetUri = assetUri;
+        }
+
+        private void PlatformInitialize(string fileName)
+        {
+            // Nothing to do here
+        }
+
+        static void AndroidPlayer_Completion(object sender, EventArgs e)
+        {
+            var playingSong = _playingSong;
+            _playingSong = null;
+
+            if (playingSong != null && playingSong.DonePlaying != null)
+                playingSong.DonePlaying(sender, e);
+        }
+
+        /// <summary>
+        /// Set the event handler for "Finished Playing". Done this way to prevent multiple bindings.
+        /// </summary>
+        internal void SetEventHandler(FinishedPlayingHandler handler)
+        {
+            if (DonePlaying != null)
+                return;
+            DonePlaying += handler;
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            // Appears to be a noOp on Android
+        }
+
+        internal void Play(TimeSpan? startPosition)
+        {
+            // Prepare the player
+            _androidPlayer.Reset();
+
+            if (assetUri != null)
+            {
+                _androidPlayer.SetDataSource(MediaLibrary.Context, this.assetUri);
+            }
+            else
+            {
+                var afd = Game.Activity.Assets.OpenFd(_name);
+                if (afd == null)
+                    return;
+
+                _androidPlayer.SetDataSource(afd.FileDescriptor, afd.StartOffset, afd.Length);
+            }
+
+
+            _androidPlayer.Prepare();
+            _androidPlayer.Looping = MediaPlayer.IsRepeating;
+            _playingSong = this;
+
+            if (startPosition.HasValue)
+                Position = startPosition.Value;
+            _androidPlayer.Start();
+            _playCount++;
+        }
+
+        internal void Resume()
+        {
+            _androidPlayer.Start();
+        }
+
+        internal void Pause()
+        {
+            _androidPlayer.Pause();
+        }
+
+        internal void Stop()
+        {
+            _androidPlayer.Stop();
+            _playingSong = null;
+            _playCount = 0;
+            position = TimeSpan.Zero;
+        }
+
+        internal float Volume
+        {
+            get
+            {
+                return 0.0f;
+            }
+
+            set
+            {
+                _androidPlayer.SetVolume(value, value);
+            }
+        }
+
+        public TimeSpan Position
+        {
+            get
+            {
+                if (_playingSong == this && _androidPlayer.IsPlaying)
+                    position = TimeSpan.FromMilliseconds(_androidPlayer.CurrentPosition);
+
+                return position;
+            }
+            set
+            {
+                _androidPlayer.SeekTo((int)value.TotalMilliseconds);   
+            }
+        }
+
+
+        private Album PlatformGetAlbum()
+        {
+            return this.album;
+        }
+
+        private Artist PlatformGetArtist()
+        {
+            return this.artist;
+        }
+
+        private Genre PlatformGetGenre()
+        {
+            return this.genre;
+        }
+
+        private TimeSpan PlatformGetDuration()
+        {
+            return this.assetUri != null ? this.duration : _duration;
+        }
+
+        private bool PlatformIsProtected()
+        {
+            return false;
+        }
+
+        private bool PlatformIsRated()
+        {
+            return false;
+        }
+
+        private string PlatformGetName()
+        {
+            return this.assetUri != null ? this.name : Path.GetFileNameWithoutExtension(_name);
+        }
+
+        private int PlatformGetPlayCount()
+        {
+            return _playCount;
+        }
+
+        private int PlatformGetRating()
+        {
+            return 0;
+        }
+
+        private int PlatformGetTrackNumber()
+        {
+            return 0;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Media/Song.Default.cs b/MonoGame.Framework/Media/Song.Default.cs
new file mode 100644
index 00000000000..5e121482ecb
--- /dev/null
+++ b/MonoGame.Framework/Media/Song.Default.cs
@@ -0,0 +1,179 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using Microsoft.Xna.Framework.Audio;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class Song : IEquatable<Song>, IDisposable
+    {
+        private SoundEffectInstance _sound;
+
+        private void PlatformInitialize(string fileName)
+        {
+
+#if MONOMAC || (WINDOWS && OPENGL) || WEB
+
+            using (var s = File.OpenRead(_name))
+            {
+                var soundEffect = SoundEffect.FromStream(s);
+                _sound = soundEffect.CreateInstance();
+            }
+#endif
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            if (_sound == null)
+                return;
+
+            _sound.Dispose();
+            _sound = null;
+        }
+
+		internal void OnFinishedPlaying (object sender, EventArgs args)
+		{
+			if (DonePlaying == null)
+				return;
+			
+			DonePlaying(sender, args);
+		}
+
+		/// <summary>
+		/// Set the event handler for "Finished Playing". Done this way to prevent multiple bindings.
+		/// </summary>
+		internal void SetEventHandler(FinishedPlayingHandler handler)
+		{
+			if (DonePlaying != null)
+				return;
+			
+			DonePlaying += handler;
+		}
+
+		internal void Play(TimeSpan? startPosition)
+		{	
+			if (startPosition.HasValue)
+				throw new Exception("startPosition not implemented on this Platform"); //Should be possible to implement in OpenAL
+			if ( _sound == null )
+				return;
+
+            PlatformPlay();
+
+            _playCount++;
+        }
+
+        private void PlatformPlay()
+        {
+            _sound.Play();
+        }
+
+		internal void Resume()
+		{
+			if (_sound == null)
+				return;
+
+            PlatformResume();
+		}
+
+        private void PlatformResume()
+        {
+            _sound.Resume();
+        }
+		
+		internal void Pause()
+		{			            
+			if ( _sound == null )
+				return;
+			
+			_sound.Pause();
+        }
+		
+		internal void Stop()
+		{
+			if ( _sound == null )
+				return;
+			
+			_sound.Stop();
+			_playCount = 0;
+		}
+
+		internal float Volume
+		{
+			get
+			{
+				if (_sound != null)
+					return _sound.Volume;
+				else
+					return 0.0f;
+			}
+			
+			set
+			{
+				if ( _sound != null && _sound.Volume != value )
+					_sound.Volume = value;
+			}			
+		}
+
+		internal TimeSpan Position
+        {
+            get
+            {
+                // TODO: Implement
+                return new TimeSpan(0);				
+            }
+        }
+
+        private Album PlatformGetAlbum()
+        {
+            return null;
+        }
+
+        private Artist PlatformGetArtist()
+        {
+            return null;
+        }
+
+        private Genre PlatformGetGenre()
+        {
+            return null;
+        }
+
+        private TimeSpan PlatformGetDuration()
+        {
+            return _duration;
+        }
+
+        private bool PlatformIsProtected()
+        {
+            return false;
+        }
+
+        private bool PlatformIsRated()
+        {
+            return false;
+        }
+
+        private string PlatformGetName()
+        {
+            return Path.GetFileNameWithoutExtension(_name);
+        }
+
+        private int PlatformGetPlayCount()
+        {
+            return _playCount;
+        }
+
+        private int PlatformGetRating()
+        {
+            return 0;
+        }
+
+        private int PlatformGetTrackNumber()
+        {
+            return 0;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Media/Song.IOS.cs b/MonoGame.Framework/Media/Song.IOS.cs
new file mode 100644
index 00000000000..9c89a6976d6
--- /dev/null
+++ b/MonoGame.Framework/Media/Song.IOS.cs
@@ -0,0 +1,237 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using Foundation;
+using AVFoundation;
+using MediaPlayer;
+using CoreMedia;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class Song
+    {
+        private Album album;
+        private Artist artist;
+        private Genre genre;
+        private string title;
+        private TimeSpan duration;
+        #if !TVOS
+        private MPMediaItem mediaItem;
+        #endif
+        private AVPlayerItem _sound;
+        private AVPlayer _player;
+        private NSUrl assetUrl;
+        private NSObject playToEndObserver;
+
+        [CLSCompliant(false)]
+        public NSUrl AssetUrl
+        {
+            get { return this.assetUrl; }
+        }
+
+        #if !TVOS
+        internal Song(Album album, Artist artist, Genre genre, string title, TimeSpan duration, MPMediaItem mediaItem, NSUrl assetUrl)
+        #else
+        internal Song(Album album, Artist artist, Genre genre, string title, TimeSpan duration, object mediaItem, NSUrl assetUrl)
+        #endif
+        {
+            this.album = album;
+            this.artist = artist;
+            this.genre = genre;
+            this.title = title;
+            this.duration = duration;
+            #if !TVOS
+            this.mediaItem = mediaItem;
+            #endif
+            this.assetUrl = assetUrl;
+        }
+
+        private void PlatformInitialize(string fileName)
+        {
+            this.PlatformInitialize(NSUrl.FromFilename(fileName));
+        }
+
+        private void PlatformInitialize(NSUrl url)
+        {
+            _sound = AVPlayerItem.FromUrl(url);
+            _player = AVPlayer.FromPlayerItem(_sound);
+            playToEndObserver = AVPlayerItem.Notifications.ObserveDidPlayToEndTime(OnFinishedPlaying);
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            if (_sound == null)
+                return;
+                
+            playToEndObserver.Dispose ();
+            playToEndObserver = null;
+
+            _sound.Dispose();
+            _sound = null;
+
+            _player.Dispose();
+            _player = null;
+        }
+
+        internal void OnFinishedPlaying (object sender, NSNotificationEventArgs args)
+		{
+			if (DonePlaying != null)
+			    DonePlaying(sender, args);
+		}
+
+		/// <summary>
+		/// Set the event handler for "Finished Playing". Done this way to prevent multiple bindings.
+		/// </summary>
+		internal void SetEventHandler(FinishedPlayingHandler handler)
+		{
+			if (DonePlaying != null)
+				return;
+			
+			DonePlaying += handler;
+		}
+
+        internal void Play(TimeSpan? startPosition)
+        {
+            if (_player == null)
+            {
+                // MediaLibrary items are lazy loaded
+                if (assetUrl != null)
+                    this.PlatformInitialize (assetUrl);
+                else
+                    return;
+            }
+
+            PlatformPlay(startPosition);
+
+            _playCount++;
+        }
+
+        private void PlatformPlay(TimeSpan? startPosition)
+        {
+            
+            if (startPosition.HasValue)
+                _player.Seek(CMTime.FromSeconds(startPosition.Value.TotalSeconds, 1));
+            else
+                _player.Seek(CMTime.Zero); // Seek to start to ensure playback at the start.
+            
+            _player.Play();
+        }
+
+		internal void Resume()
+		{
+            if (_player == null)
+				return;
+
+            PlatformResume();
+		}
+
+        private void PlatformResume()
+        {
+			_player.Play();
+        }
+		
+		internal void Pause()
+		{			            
+            if (_player == null)
+				return;
+			
+            _player.Pause();
+        }
+		
+		internal void Stop()
+		{
+            if (_player == null)
+				return;
+			
+            _player.Pause();
+			_playCount = 0;
+		}
+
+		internal float Volume
+		{
+			get
+			{
+                if (_player != null)
+                    return _player.Volume;
+				else
+					return 0.0f;
+			}
+			
+			set
+			{
+                if ( _player != null && _player.Volume != value )
+                    _player.Volume = value;
+			}			
+		}
+
+		internal TimeSpan Position
+        {
+            get
+            {
+                return TimeSpan.FromSeconds(_player.CurrentTime.Seconds);		
+            }
+            set
+            {
+                _player.Seek(CMTime.FromSeconds(value.TotalSeconds, 1000));
+            }
+        }
+
+        private Album PlatformGetAlbum()
+        {
+            return this.album;
+        }
+
+        private Artist PlatformGetArtist()
+        {
+            return this.artist;
+        }
+
+        private Genre PlatformGetGenre()
+        {
+            return this.genre;
+        }
+
+        private TimeSpan PlatformGetDuration()
+        {
+            #if !TVOS
+            if (this.mediaItem != null)
+                return this.duration;
+            #endif
+            return _duration;
+        }
+
+        private bool PlatformIsProtected()
+        {
+            return false;
+        }
+
+        private bool PlatformIsRated()
+        {
+            return false;
+        }
+
+        private string PlatformGetName()
+        {
+            return this.title ?? Path.GetFileNameWithoutExtension(_name);
+        }
+
+        private int PlatformGetPlayCount()
+        {
+            return _playCount;
+        }
+
+        private int PlatformGetRating()
+        {
+            return 0;
+        }
+
+        private int PlatformGetTrackNumber()
+        {
+            return 0;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Media/Song.NVorbis.cs b/MonoGame.Framework/Media/Song.NVorbis.cs
new file mode 100644
index 00000000000..073c95c7687
--- /dev/null
+++ b/MonoGame.Framework/Media/Song.NVorbis.cs
@@ -0,0 +1,158 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using Microsoft.Xna.Framework.Audio;
+using MonoGame.OpenAL;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class Song : IEquatable<Song>, IDisposable
+    {
+        private OggStream stream;
+        private float _volume = 1f;
+
+        private void PlatformInitialize(string fileName)
+        {
+            // init OpenAL if need be
+            OpenALSoundController.EnsureInitialized();
+
+            stream = new OggStream(fileName, OnFinishedPlaying);
+            stream.Prepare();
+
+            _duration = stream.GetLength();
+        }
+        
+        internal void SetEventHandler(FinishedPlayingHandler handler) { }
+
+        internal void OnFinishedPlaying()
+        {
+            MediaPlayer.OnSongFinishedPlaying(null, null);
+        }
+		
+        void PlatformDispose(bool disposing)
+        {
+            if (stream == null)
+                return;
+
+            stream.Dispose();
+            stream = null;
+        }
+
+        internal void Play(TimeSpan? startPosition)
+        {
+            if (stream == null)
+                return;
+
+            stream.Play();
+            if (startPosition != null)
+                stream.SeekToPosition((TimeSpan)startPosition);
+
+            _playCount++;
+        }
+
+        internal void Resume()
+        {
+            if (stream == null)
+                return;
+
+            stream.Resume();
+        }
+
+        internal void Pause()
+        {
+            if (stream == null)
+                return;
+
+            stream.Pause();
+        }
+
+        internal void Stop()
+        {
+            if (stream == null)
+                return;
+
+            stream.Stop();
+            _playCount = 0;
+        }
+
+        internal float Volume
+        {
+            get
+            {
+                if (stream == null)
+                    return 0.0f;
+                return _volume; 
+            }
+            set
+            {
+                _volume = value;
+                if (stream != null)
+                    stream.Volume = _volume;
+            }
+        }
+
+        public TimeSpan Position
+        {
+            get
+            {
+                if (stream == null)
+                    return TimeSpan.FromSeconds(0.0);
+                return stream.GetPosition();
+            }
+        }
+
+        private Album PlatformGetAlbum()
+        {
+            return null;
+        }
+
+        private Artist PlatformGetArtist()
+        {
+            return null;
+        }
+
+        private Genre PlatformGetGenre()
+        {
+            return null;
+        }
+
+        private TimeSpan PlatformGetDuration()
+        {
+            return _duration;
+        }
+
+        private bool PlatformIsProtected()
+        {
+            return false;
+        }
+
+        private bool PlatformIsRated()
+        {
+            return false;
+        }
+
+        private string PlatformGetName()
+        {
+            return Path.GetFileNameWithoutExtension(_name);
+        }
+
+        private int PlatformGetPlayCount()
+        {
+            return _playCount;
+        }
+
+        private int PlatformGetRating()
+        {
+            return 0;
+        }
+
+        private int PlatformGetTrackNumber()
+        {
+            return 0;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Media/Song.WMS.cs b/MonoGame.Framework/Media/Song.WMS.cs
new file mode 100644
index 00000000000..4aa9626fcfd
--- /dev/null
+++ b/MonoGame.Framework/Media/Song.WMS.cs
@@ -0,0 +1,144 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using SharpDX;
+using SharpDX.MediaFoundation;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class Song : IEquatable<Song>, IDisposable
+    {
+        private Topology _topology;
+
+        internal Topology Topology { get { return _topology; } }
+
+        private void PlatformInitialize(string fileName)
+        {
+            if (_topology != null)
+                return;
+
+            MediaManagerState.CheckStartup();
+
+            MediaFactory.CreateTopology(out _topology);
+
+            SharpDX.MediaFoundation.MediaSource mediaSource;
+            {
+                SourceResolver resolver = new SourceResolver();
+
+                ComObject source = resolver.CreateObjectFromURL(FilePath, SourceResolverFlags.MediaSource);
+                mediaSource = source.QueryInterface<SharpDX.MediaFoundation.MediaSource>();
+                resolver.Dispose();
+                source.Dispose();
+            }
+
+            PresentationDescriptor presDesc;
+            mediaSource.CreatePresentationDescriptor(out presDesc);
+
+            for (var i = 0; i < presDesc.StreamDescriptorCount; i++)
+            {
+                SharpDX.Mathematics.Interop.RawBool selected;
+                StreamDescriptor desc;
+                presDesc.GetStreamDescriptorByIndex(i, out selected, out desc);
+
+                if (selected)
+                {
+                    TopologyNode sourceNode;
+                    MediaFactory.CreateTopologyNode(TopologyType.SourceStreamNode, out sourceNode);
+
+                    sourceNode.Set(TopologyNodeAttributeKeys.Source, mediaSource);
+                    sourceNode.Set(TopologyNodeAttributeKeys.PresentationDescriptor, presDesc);
+                    sourceNode.Set(TopologyNodeAttributeKeys.StreamDescriptor, desc);
+
+                    TopologyNode outputNode;
+                    MediaFactory.CreateTopologyNode(TopologyType.OutputNode, out outputNode);
+
+                    var typeHandler = desc.MediaTypeHandler;
+                    var majorType = typeHandler.MajorType;
+                    if (majorType != MediaTypeGuids.Audio)
+                        throw new NotSupportedException("The song contains video data!");
+
+                    Activate activate;
+                    MediaFactory.CreateAudioRendererActivate(out activate);
+                    outputNode.Object = activate;
+
+                    _topology.AddNode(sourceNode);
+                    _topology.AddNode(outputNode);
+                    sourceNode.ConnectOutput(0, outputNode, 0);
+
+                    sourceNode.Dispose();
+                    outputNode.Dispose();
+                    typeHandler.Dispose();
+                    activate.Dispose();
+                }
+
+                desc.Dispose();
+            }
+
+            presDesc.Dispose();
+            mediaSource.Dispose();
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            if (_topology != null)
+            {
+                _topology.Dispose();
+                _topology = null;
+            }
+        }
+        
+        private Album PlatformGetAlbum()
+        {
+            return null;
+        }
+
+        private Artist PlatformGetArtist()
+        {
+            return null;
+        }
+
+        private Genre PlatformGetGenre()
+        {
+            return null;
+        }
+
+        private TimeSpan PlatformGetDuration()
+        {
+            return _duration;
+        }
+
+        private bool PlatformIsProtected()
+        {
+            return false;
+        }
+
+        private bool PlatformIsRated()
+        {
+            return false;
+        }
+
+        private string PlatformGetName()
+        {
+            return Path.GetFileNameWithoutExtension(_name);
+        }
+
+        private int PlatformGetPlayCount()
+        {
+            return _playCount;
+        }
+
+        private int PlatformGetRating()
+        {
+            return 0;
+        }
+
+        private int PlatformGetTrackNumber()
+        {
+            return 0;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Media/Song.WinRT.cs b/MonoGame.Framework/Media/Song.WinRT.cs
new file mode 100644
index 00000000000..e78907172b0
--- /dev/null
+++ b/MonoGame.Framework/Media/Song.WinRT.cs
@@ -0,0 +1,116 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using Windows.Storage;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class Song
+    {
+        private Album album;
+        private Artist artist;
+        private Genre genre;
+        
+		private MusicProperties musicProperties;
+
+        [CLSCompliant(false)]
+        public StorageFile StorageFile
+        {
+            get { return this.musicProperties.File; }
+        }
+        
+		internal Song(Album album, Artist artist, Genre genre, MusicProperties musicProperties)
+		{
+            this.album = album;
+            this.artist = artist;
+            this.genre = genre;
+            this.musicProperties = musicProperties;
+		}
+
+		private void PlatformInitialize(string fileName)
+        {
+
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+
+        }
+
+        private Album PlatformGetAlbum()
+        {
+            return this.album;
+        }
+
+        private void PlatformSetAlbum(Album album)
+        {
+            this.album = album;
+        }
+
+        private Artist PlatformGetArtist()
+        {
+            return this.artist;
+        }
+
+        private Genre PlatformGetGenre()
+        {
+            return this.genre;
+        }
+
+        private TimeSpan PlatformGetDuration()
+        {
+            if (this.musicProperties != null)
+                return this.musicProperties.Duration;
+
+            return _duration;
+        }
+
+        private bool PlatformIsProtected()
+        {
+            if (this.musicProperties != null)
+                return this.musicProperties.IsProtected;
+
+            return false;
+        }
+
+        private bool PlatformIsRated()
+        {
+            if (this.musicProperties != null)
+                return this.musicProperties.Rating != 0;
+
+            return false;
+        }
+
+        private string PlatformGetName()
+        {
+            if (this.musicProperties != null)
+                return this.musicProperties.Title;
+
+            return Path.GetFileNameWithoutExtension(_name);
+        }
+
+        private int PlatformGetPlayCount()
+        {
+            return _playCount;
+        }
+
+        private int PlatformGetRating()
+        {
+            if (this.musicProperties != null)
+                return this.musicProperties.Rating;
+
+            return 0;
+        }
+
+        private int PlatformGetTrackNumber()
+        {
+            if (this.musicProperties != null)
+                return this.musicProperties.TrackNumber;
+
+            return 0;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Media/Song.cs b/MonoGame.Framework/Media/Song.cs
new file mode 100644
index 00000000000..12208a0dd17
--- /dev/null
+++ b/MonoGame.Framework/Media/Song.cs
@@ -0,0 +1,185 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class Song : IEquatable<Song>, IDisposable
+    {
+        private string _name;
+		private int _playCount = 0;
+        private TimeSpan _duration = TimeSpan.Zero;
+        bool disposed;
+        /// <summary>
+        /// Gets the Album on which the Song appears.
+        /// </summary>
+        public Album Album
+        {
+            get { return PlatformGetAlbum(); }
+#if WINDOWS_UAP
+            internal set { PlatformSetAlbum(value); }
+#endif
+        }
+
+        /// <summary>
+        /// Gets the Artist of the Song.
+        /// </summary>
+        public Artist Artist
+        {
+            get { return PlatformGetArtist(); }
+        }
+
+        /// <summary>
+        /// Gets the Genre of the Song.
+        /// </summary>
+        public Genre Genre
+        {
+            get { return PlatformGetGenre(); }
+        }
+        
+        public bool IsDisposed
+        {
+            get { return disposed; }
+        }
+
+#if ANDROID || OPENAL || WEB || IOS
+        internal delegate void FinishedPlayingHandler(object sender, EventArgs args);
+#if !DESKTOPGL
+        event FinishedPlayingHandler DonePlaying;
+#endif
+#endif
+        internal Song(string fileName, int durationMS)
+            : this(fileName)
+        {
+            _duration = TimeSpan.FromMilliseconds(durationMS);
+        }
+
+		internal Song(string fileName)
+		{			
+			_name = fileName;
+
+            PlatformInitialize(fileName);
+        }
+
+        ~Song()
+        {
+            Dispose(false);
+        }
+
+        internal string FilePath
+		{
+			get { return _name; }
+		}
+
+        /// <summary>
+        /// Returns a song that can be played via <see cref="MediaPlayer"/>.
+        /// </summary>
+        /// <param name="name">The name for the song. See <see cref="Song.Name"/>.</param>
+        /// <param name="uri">The path to the song file.</param>
+        /// <returns></returns>
+        public static Song FromUri(string name, Uri uri)
+        {
+            var song = new Song(uri.OriginalString);
+            song._name = name;
+            return song;
+        }
+		
+		public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+        
+        void Dispose(bool disposing)
+        {
+            if (!disposed)
+            {
+                if (disposing)
+                {
+                    PlatformDispose(disposing);
+                }
+
+                disposed = true;
+            }
+        }
+
+        public override int GetHashCode ()
+		{
+			return base.GetHashCode ();
+		}
+
+        public bool Equals(Song song)
+        {
+#if DIRECTX
+            return song != null && song.FilePath == FilePath;
+#else
+			return ((object)song != null) && (Name == song.Name);
+#endif
+		}
+		
+		
+		public override bool Equals(Object obj)
+		{
+			if(obj == null)
+			{
+				return false;
+			}
+			
+			return Equals(obj as Song);  
+		}
+		
+		public static bool operator ==(Song song1, Song song2)
+		{
+			if((object)song1 == null)
+			{
+				return (object)song2 == null;
+			}
+
+			return song1.Equals(song2);
+		}
+		
+		public static bool operator !=(Song song1, Song song2)
+		{
+		  return ! (song1 == song2);
+		}
+
+        public TimeSpan Duration
+        {
+            get { return PlatformGetDuration(); }
+        }	
+
+        public bool IsProtected
+        {
+            get { return PlatformIsProtected(); }
+        }
+
+        public bool IsRated
+        {
+            get { return PlatformIsRated(); }
+        }
+
+        public string Name
+        {
+            get { return PlatformGetName(); }
+        }
+
+        public int PlayCount
+        {
+            get { return PlatformGetPlayCount(); }
+        }
+
+        public int Rating
+        {
+            get { return PlatformGetRating(); }
+        }
+
+        public int TrackNumber
+        {
+            get { return PlatformGetTrackNumber(); }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Media/SongCollection.cs b/MonoGame.Framework/Media/SongCollection.cs
new file mode 100644
index 00000000000..74176040d42
--- /dev/null
+++ b/MonoGame.Framework/Media/SongCollection.cs
@@ -0,0 +1,122 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework.Media
+{
+	public class SongCollection : ICollection<Song>, IEnumerable<Song>, IEnumerable, IDisposable
+	{
+		private bool isReadOnly = false;
+		private List<Song> innerlist = new List<Song>();
+
+        internal SongCollection()
+        {
+
+        }
+
+        internal SongCollection(List<Song> songs)
+        {
+            this.innerlist = songs;
+        }
+
+		public void Dispose()
+        {
+        }
+		
+		public IEnumerator<Song> GetEnumerator()
+        {
+            return innerlist.GetEnumerator();
+        }
+		
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return innerlist.GetEnumerator();
+        }
+
+        public int Count
+        {
+            get
+            {
+				return innerlist.Count;
+            }
+        }
+		
+		public bool IsReadOnly
+        {
+		    get
+		    {
+		        return this.isReadOnly;
+		    }
+        }
+
+        public Song this[int index]
+        {
+            get
+            {
+				return this.innerlist[index];
+            }
+        }
+		
+		public void Add(Song item)
+        {
+
+            if (item == null)
+                throw new ArgumentNullException();
+
+            if (innerlist.Count == 0)
+            {
+                this.innerlist.Add(item);
+                return;
+            }
+
+            for (int i = 0; i < this.innerlist.Count; i++)
+            {
+                if (item.TrackNumber < this.innerlist[i].TrackNumber)
+                {
+                    this.innerlist.Insert(i, item);
+                    return;
+                }
+            }
+
+            this.innerlist.Add(item);
+        }
+		
+		public void Clear()
+        {
+            innerlist.Clear();
+        }
+        
+        public SongCollection Clone()
+        {
+            SongCollection sc = new SongCollection();
+            foreach (Song song in this.innerlist)
+                sc.Add(song);
+            return sc;
+        }
+        
+        public bool Contains(Song item)
+        {
+            return innerlist.Contains(item);
+        }
+        
+        public void CopyTo(Song[] array, int arrayIndex)
+        {
+            innerlist.CopyTo(array, arrayIndex);
+        }
+		
+		public int IndexOf(Song item)
+        {
+            return innerlist.IndexOf(item);
+        }
+        
+        public bool Remove(Song item)
+        {
+            return innerlist.Remove(item);
+        }
+	}
+}
+
diff --git a/MonoGame.Framework/Media/Video.Android.cs b/MonoGame.Framework/Media/Video.Android.cs
new file mode 100644
index 00000000000..db257a8e88e
--- /dev/null
+++ b/MonoGame.Framework/Media/Video.Android.cs
@@ -0,0 +1,41 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Linq;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    /// <summary>
+    /// Represents a video.
+    /// </summary>
+    public sealed partial class Video : IDisposable
+    {
+        internal Android.Media.MediaPlayer Player;
+
+        private void PlatformInitialize()
+        {
+            Player = new Android.Media.MediaPlayer();
+            if (Player != null)
+            {
+                var afd = Game.Activity.Assets.OpenFd(FileName);
+                if (afd != null)
+                {
+                    Player.SetDataSource(afd.FileDescriptor, afd.StartOffset, afd.Length);
+                    Player.Prepare();
+                }
+            }
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            if (Player == null)
+                return;
+
+            Player.Dispose();
+            Player = null;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/Video.IOS.cs b/MonoGame.Framework/Media/Video.IOS.cs
new file mode 100644
index 00000000000..495d9aaa184
--- /dev/null
+++ b/MonoGame.Framework/Media/Video.IOS.cs
@@ -0,0 +1,60 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+using MediaPlayer;
+using Foundation;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    /// <summary>
+    /// Represents a video.
+    /// </summary>
+    public sealed partial class Video : IDisposable
+    {
+        internal MPMoviePlayerViewController MovieView { get; private set; }
+
+        /*
+        // NOTE: https://developer.apple.com/library/ios/documentation/MediaPlayer/Reference/MPMoviePlayerController_Class/Reference/Reference.html
+        // It looks like BackgroundColor doesn't even exist anymore
+        // in recent versions of iOS... Why still have this?
+        public Color BackgroundColor
+        {
+            get
+            {
+                var col = MovieView.MoviePlayer.BackgroundColor;
+                return new Color(col.X, col.Y, col.Z, col.W);
+            }
+
+            set
+            {
+                var col = value.ToVector4();
+                return MovieView.MoviePlayer.BackgroundColor = UIKit.UIColor(col.X, col.Y, col.Z, col.W);
+            }
+        }
+        */
+
+        private void PlatformInitialize()
+        {
+            var url = NSUrl.FromFilename(Path.GetFullPath(FileName));
+
+            MovieView = new MPMoviePlayerViewController(url);
+            MovieView.MoviePlayer.ScalingMode = MPMovieScalingMode.AspectFill;
+            MovieView.MoviePlayer.ControlStyle = MPMovieControlStyle.None;
+            MovieView.MoviePlayer.PrepareToPlay();
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            if (MovieView == null)
+                return;
+            
+            MovieView.Dispose();
+            MovieView = null;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/Video.MacOS.cs b/MonoGame.Framework/Media/Video.MacOS.cs
new file mode 100644
index 00000000000..e8e0746782a
--- /dev/null
+++ b/MonoGame.Framework/Media/Video.MacOS.cs
@@ -0,0 +1,60 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+using ObjCRuntime;
+using Foundation;
+using AVFoundation;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    /// <summary>
+    /// Represents a video.
+    /// </summary>
+    public sealed partial class Video : IDisposable
+    {
+        AVPlayerItem movie;
+
+        internal AVPlayer Player { get; private set; }
+
+        internal float Volume
+        {
+            get { return Player.Volume; }
+            set
+            {
+                // TODO When Xamarain fix the set Volume mMovie.Volume = value;
+            }
+        }
+
+        internal TimeSpan CurrentPosition
+        {
+            get { return new TimeSpan(movie.CurrentTime.Value); }
+        }
+
+        private void PlatformInitialize()
+        {
+            var err = new NSError();
+
+            movie = AVPlayerItem.FromUrl(NSUrl.FromFilename(FileName));
+            Player = new AVPlayer(movie);
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            if (Player != null)
+            {
+                Player.Dispose();
+                Player = null;
+            }
+
+            if (movie != null)
+            {
+                movie.Dispose();
+                movie = null;
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/Video.WMS.cs b/MonoGame.Framework/Media/Video.WMS.cs
new file mode 100644
index 00000000000..f65aac44d92
--- /dev/null
+++ b/MonoGame.Framework/Media/Video.WMS.cs
@@ -0,0 +1,113 @@
+using SharpDX;
+using SharpDX.MediaFoundation;
+using System;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class Video : IDisposable
+    {
+        private Topology _topology;
+        internal Topology Topology { get { return _topology; } }
+
+        internal VideoSampleGrabber SampleGrabber { get; private set; }
+
+        MediaType _mediaType;
+
+        private void PlatformInitialize()
+        {
+            if (Topology != null)
+                return;
+
+            MediaManagerState.CheckStartup();
+
+            MediaFactory.CreateTopology(out _topology);
+
+            SharpDX.MediaFoundation.MediaSource mediaSource;
+            {
+                SourceResolver resolver = new SourceResolver();
+
+                ObjectType otype;
+                ComObject source = resolver.CreateObjectFromURL(FileName, SourceResolverFlags.MediaSource, null, out otype);
+                mediaSource = source.QueryInterface<SharpDX.MediaFoundation.MediaSource>();
+                resolver.Dispose();
+                source.Dispose();
+            }
+
+            PresentationDescriptor presDesc;
+            mediaSource.CreatePresentationDescriptor(out presDesc);
+
+            for (var i = 0; i < presDesc.StreamDescriptorCount; i++)
+            {
+                SharpDX.Mathematics.Interop.RawBool selected;
+                StreamDescriptor desc;
+                presDesc.GetStreamDescriptorByIndex(i, out selected, out desc);
+
+                if (selected)
+                {
+                    TopologyNode sourceNode;
+                    MediaFactory.CreateTopologyNode(TopologyType.SourceStreamNode, out sourceNode);
+
+                    sourceNode.Set(TopologyNodeAttributeKeys.Source, mediaSource);
+                    sourceNode.Set(TopologyNodeAttributeKeys.PresentationDescriptor, presDesc);
+                    sourceNode.Set(TopologyNodeAttributeKeys.StreamDescriptor, desc);
+
+                    TopologyNode outputNode;
+                    MediaFactory.CreateTopologyNode(TopologyType.OutputNode, out outputNode);
+
+                    var majorType = desc.MediaTypeHandler.MajorType;
+                    if (majorType == MediaTypeGuids.Video)
+                    {
+                        Activate activate;
+
+                        SampleGrabber = new VideoSampleGrabber();
+
+                        _mediaType = new MediaType();
+
+                        _mediaType.Set(MediaTypeAttributeKeys.MajorType, MediaTypeGuids.Video);
+
+                        // Specify that we want the data to come in as RGB32.
+                        _mediaType.Set(MediaTypeAttributeKeys.Subtype, new Guid("00000016-0000-0010-8000-00AA00389B71"));
+
+                        MediaFactory.CreateSampleGrabberSinkActivate(_mediaType, SampleGrabber, out activate);
+                        outputNode.Object = activate;
+                    }
+
+                    if (majorType == MediaTypeGuids.Audio)
+                    {
+                        Activate activate;
+                        MediaFactory.CreateAudioRendererActivate(out activate);
+
+                        outputNode.Object = activate;
+                    }
+
+                    _topology.AddNode(sourceNode);
+                    _topology.AddNode(outputNode);
+                    sourceNode.ConnectOutput(0, outputNode, 0);
+
+                    sourceNode.Dispose();
+                    outputNode.Dispose();
+                }
+
+                desc.Dispose();
+            }
+
+            presDesc.Dispose();
+            mediaSource.Dispose();
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            if (_topology != null)
+            {
+                _topology.Dispose();
+                _topology = null;
+            }
+
+            if (SampleGrabber != null)
+            {
+                SampleGrabber.Dispose();
+                SampleGrabber = null;
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/Video.cs b/MonoGame.Framework/Media/Video.cs
new file mode 100644
index 00000000000..5a6d23bf1b0
--- /dev/null
+++ b/MonoGame.Framework/Media/Video.cs
@@ -0,0 +1,94 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    /// <summary>
+    /// Represents a video.
+    /// </summary>
+    public sealed partial class Video : IDisposable
+	{
+		private bool _disposed;
+
+		#region Public API
+
+		/// <summary>
+		/// I actually think this is a file PATH...
+		/// </summary>
+		public string FileName { get; private set; }
+
+		/// <summary>
+		/// Gets the duration of the Video.
+        /// </summary>
+        public TimeSpan Duration { get; internal set; }
+
+        /// <summary>
+        /// Gets the frame rate of this video.
+        /// </summary>
+        public float FramesPerSecond { get; internal set; }
+
+        /// <summary>
+        /// Gets the height of this video, in pixels.
+        /// </summary>
+        public int Height { get; internal set; }
+
+        /// <summary>
+        /// Gets the VideoSoundtrackType for this video.
+        /// </summary>
+        public VideoSoundtrackType VideoSoundtrackType { get; internal set; }
+
+        /// <summary>
+        /// Gets the width of this video, in pixels.
+        /// </summary>
+        public int Width { get; internal set; }
+
+        #endregion
+
+        #region Internal API
+
+        internal Video(string fileName, float durationMS) :
+            this(fileName)
+        {
+            Duration = TimeSpan.FromMilliseconds(durationMS);
+        }
+
+        internal Video(string fileName)
+        {
+            FileName = fileName;
+
+#if !WINDOWS_UAP
+            PlatformInitialize();
+#endif
+        }
+
+        ~Video()
+        {
+            Dispose(false);
+        }
+
+        #endregion
+
+        #region IDisposable Implementation
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                //PlatformDispose(disposing);
+                _disposed = true;
+            }
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Media/VideoPlayer.Android.cs b/MonoGame.Framework/Media/VideoPlayer.Android.cs
new file mode 100644
index 00000000000..8a79e9660bb
--- /dev/null
+++ b/MonoGame.Framework/Media/VideoPlayer.Android.cs
@@ -0,0 +1,79 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Android.Widget;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class VideoPlayer : IDisposable
+    {
+        private Game _game;
+
+        private void PlatformInitialize()
+        {
+            _game = Game.Instance;
+        }
+
+        private Texture2D PlatformGetTexture()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformGetState(ref MediaState result)
+        {
+        }
+
+        private void PlatformPause()
+        {
+            _currentVideo.Player.Pause();
+        }
+
+        private void PlatformResume()
+        {
+            _currentVideo.Player.Start();
+        }
+
+        private void PlatformPlay()
+        {
+            _currentVideo.Player.SetDisplay(((AndroidGameWindow)_game.Window).GameView.Holder);
+            _currentVideo.Player.Start();
+            
+            AndroidGamePlatform.IsPlayingVdeo = true;
+        }
+
+        private void PlatformStop()
+        {
+            _currentVideo.Player.Stop();
+
+            AndroidGamePlatform.IsPlayingVdeo = false;
+            _currentVideo.Player.SetDisplay(null);
+        }
+
+        private void PlatformSetIsLooped()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSetIsMuted()
+        {
+            throw new NotImplementedException();
+        }
+
+        private TimeSpan PlatformGetPlayPosition()
+        {
+            throw new NotImplementedException();
+        }
+
+        private TimeSpan PlatformSetVolume()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Media/VideoPlayer.IOS.cs b/MonoGame.Framework/Media/VideoPlayer.IOS.cs
new file mode 100644
index 00000000000..c222095c79d
--- /dev/null
+++ b/MonoGame.Framework/Media/VideoPlayer.IOS.cs
@@ -0,0 +1,102 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+using MediaPlayer;
+using Foundation;
+using UIKit;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class VideoPlayer : IDisposable
+    {
+        private Game _game;
+        private iOSGamePlatform _platform;
+        private NSObject _playbackDidFinishObserver;
+
+        private void PlatformInitialize()
+        {
+            _game = Game.Instance;
+            _platform = (iOSGamePlatform)_game.Services.GetService(typeof(iOSGamePlatform));
+
+            if (_platform == null)
+                throw new InvalidOperationException("No iOSGamePlatform instance was available");
+        }
+
+        private Texture2D PlatformGetTexture()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformGetState(ref MediaState result)
+        {
+        }
+
+        private void PlatformPause()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformResume()
+        {
+            _currentVideo.MovieView.MoviePlayer.Play();
+        }
+
+        private void PlatformPlay()
+        {
+            _platform.IsPlayingVideo = true;
+
+            _playbackDidFinishObserver = NSNotificationCenter.DefaultCenter.AddObserver(
+                MPMoviePlayerController.PlaybackDidFinishNotification, OnStop);
+
+            _currentVideo.MovieView.MoviePlayer.RepeatMode = IsLooped ? MPMovieRepeatMode.One : MPMovieRepeatMode.None;
+
+            _platform.ViewController.PresentViewController(_currentVideo.MovieView, false, null);
+            _currentVideo.MovieView.MoviePlayer.Play();
+        }
+
+        private void PlatformStop()
+        {
+            if (_playbackDidFinishObserver != null)
+            {
+                NSNotificationCenter.DefaultCenter.RemoveObserver(_playbackDidFinishObserver);
+                _playbackDidFinishObserver = null;
+            }
+
+            _currentVideo.MovieView.MoviePlayer.Stop();
+            _platform.IsPlayingVideo = false;
+            _platform.ViewController.DismissViewController(false, null);
+        }
+
+        private void OnStop(NSNotification e)
+        {
+            Stop();
+        }
+
+        private TimeSpan PlatformGetPlayPosition()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSetIsLooped()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSetIsMuted()
+        {
+            throw new NotImplementedException();
+        }
+
+        private TimeSpan PlatformSetVolume()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Media/VideoPlayer.MacOS.cs b/MonoGame.Framework/Media/VideoPlayer.MacOS.cs
new file mode 100644
index 00000000000..e23100e9bbf
--- /dev/null
+++ b/MonoGame.Framework/Media/VideoPlayer.MacOS.cs
@@ -0,0 +1,119 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Foundation;
+using AVFoundation;
+using RectF = CoreGraphics.CGRect;
+using Microsoft.Xna.Framework.Graphics;
+using AppKit;
+using CoreAnimation;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class VideoPlayer : IDisposable
+    {
+        private Game _game;
+        NSSDLWindow nsWindow;
+        AVPlayerLayer layer;
+        NSView view;
+
+        private void PlatformInitialize()
+        {
+            _game = Game.Instance;
+            Sdl.Window.SDL_SysWMinfo sys = new Sdl.Window.SDL_SysWMinfo();
+            Sdl.Window.GetWindowWMInfo(_game.Window.Handle, ref sys);
+            nsWindow = new NSSDLWindow(sys.window);
+        }
+
+        private Texture2D PlatformGetTexture()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformGetState(ref MediaState result)
+        {
+        }
+
+        private void PlatformPause()
+        {
+            _currentVideo.Player.Pause();
+        }
+
+        private void PlatformResume()
+        {
+            _currentVideo.Volume = _volume;
+            _currentVideo.Player.Play();
+        }
+
+        private void PlatformPlay()
+        {
+            layer = AVPlayerLayer.FromPlayer(_currentVideo.Player);
+            view = new NSView(nsWindow.ContentView.Frame);
+            view.WantsLayer = true;
+            view.Layer = layer;
+            layer.Frame = nsWindow.ContentView.Bounds;
+            nsWindow.ContentView.AddSubview(view);
+           
+            NSNotificationCenter.DefaultCenter.AddObserver(AVPlayerItem.DidPlayToEndTimeNotification,
+                                                               notification =>
+            {
+                Stop();
+
+                if (IsLooped)
+                    PlatformPlay();
+
+            });
+
+            _currentVideo.Volume = _volume;
+            _currentVideo.Player.Play();
+
+        }
+
+        private void PlatformStop()
+        {
+            var movieView = _currentVideo.Player;
+            movieView.Pause();
+            movieView.Seek(CoreMedia.CMTime.Zero);
+
+            nsWindow.ContentView.WillRemoveSubview(view);
+            view.RemoveFromSuperview();
+            view.Dispose();
+            view = null;
+            layer.Dispose();
+            layer = null;
+        }
+
+        private void PlatformSetVolume()
+        {
+            _currentVideo.Volume = _volume;
+        }
+
+        private void PlatformSetIsLooped()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSetIsMuted()
+        {
+            throw new NotImplementedException();
+        }
+
+        private TimeSpan PlatformGetPlayPosition()
+        {
+            return _currentVideo.CurrentPosition;
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+        }
+    }
+
+    internal class NSSDLWindow : AppKit.NSWindow
+    {
+        public NSSDLWindow(IntPtr handle) : base(handle)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Media/VideoPlayer.WME.cs b/MonoGame.Framework/Media/VideoPlayer.WME.cs
new file mode 100644
index 00000000000..d35e32b7213
--- /dev/null
+++ b/MonoGame.Framework/Media/VideoPlayer.WME.cs
@@ -0,0 +1,148 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Graphics;
+
+using SharpDX.MediaFoundation;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class VideoPlayer : IDisposable
+    {
+        private MediaEngine _mediaEngine;
+        private Texture2D _lastFrame;
+
+        DXGIDeviceManager _devManager;
+
+        private void PlatformInitialize()
+        {
+            MediaManager.Startup();
+
+            _devManager = new DXGIDeviceManager();
+            _devManager.ResetDevice(Game.Instance.GraphicsDevice._d3dDevice);
+
+            using (var factory = new MediaEngineClassFactory())
+            using (var attributes = new MediaEngineAttributes
+            {
+                VideoOutputFormat = (int)SharpDX.DXGI.Format.B8G8R8A8_UNorm,
+                DxgiManager = _devManager
+                
+            })
+            {
+                _mediaEngine = new MediaEngine(factory, attributes, MediaEngineCreateFlags.None, OnMediaEngineEvent);
+            }
+        }
+
+        private void OnMediaEngineEvent(MediaEngineEvent mediaEvent, long param1, int param2)
+        {
+            if (!_mediaEngine.HasVideo())
+                return;
+
+            switch (mediaEvent)
+            {
+                case MediaEngineEvent.Play:
+                    _lastFrame = null;
+                    break;
+                
+                case MediaEngineEvent.Ended:
+
+                    if (IsLooped)
+                    {
+                        PlatformPlay();
+                        return;
+                    }   
+                    
+                    _state = MediaState.Stopped;
+                    break;
+            }
+        }
+
+        private Texture2D PlatformGetTexture()
+        {
+            // This will return a null texture if
+            // the video hasn't started playing yet
+            // or the last frame if the video is stopped
+            // as per XNA's behavior.
+            if (_state != MediaState.Playing)
+                return _lastFrame;
+
+            long pts;
+            if (!_mediaEngine.HasVideo() || !_mediaEngine.OnVideoStreamTick(out pts))
+                return _lastFrame;
+
+            _lastFrame = new Texture2D(Game.Instance.GraphicsDevice,
+                                        _currentVideo.Width,
+                                        _currentVideo.Height,
+                                        false,
+                                        SurfaceFormat.Bgra32, 
+                                        Texture2D.SurfaceType.RenderTarget);
+
+			var region = new SharpDX.Mathematics.Interop.RawRectangle(0, 0, _currentVideo.Width, _currentVideo.Height);
+            _mediaEngine.TransferVideoFrame(_lastFrame._texture, null, region, null);
+
+            return _lastFrame;
+        }
+
+        private void PlatformGetState(ref MediaState result)
+        {
+        }
+
+        private void PlatformPause()
+        {
+            // Calling PlatformGetTexture() manually will save the last frame
+            // so we can return the same one without doing unnecessary copies
+            // if GetTexture() keeps getting called while paused
+            PlatformGetTexture();
+
+            _mediaEngine.Pause();
+        }
+
+        private void PlatformResume()
+        {
+            _mediaEngine.Play();
+        }
+
+        private void PlatformPlay()
+        {
+            _mediaEngine.Source = System.IO.Path.Combine(TitleContainer.Location, _currentVideo.FileName);
+            _mediaEngine.Play();
+        }
+
+        private void PlatformStop()
+        {
+            // Calling PlatformGetTexture() manually will save the last frame
+            // so we can return the same one without doing unnecessary copies
+            // if GetTexture() keeps getting called while stopped
+            PlatformGetTexture();
+
+            _mediaEngine.Pause();
+            _mediaEngine.CurrentTime = 0.0;
+        }
+
+        private void PlatformSetIsLooped()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSetIsMuted()
+        {
+            throw new NotImplementedException();
+        }
+
+        private TimeSpan PlatformGetPlayPosition()
+        {
+            return TimeSpan.FromSeconds(_mediaEngine.CurrentTime);
+        }
+
+        private void PlatformSetVolume()
+        {
+            _mediaEngine.Volume = _volume;
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/VideoPlayer.WMS.cs b/MonoGame.Framework/Media/VideoPlayer.WMS.cs
new file mode 100644
index 00000000000..5a8112ae09e
--- /dev/null
+++ b/MonoGame.Framework/Media/VideoPlayer.WMS.cs
@@ -0,0 +1,234 @@
+using System.Diagnostics;
+using System.Threading;
+using Microsoft.Xna.Framework.Graphics;
+using SharpDX;
+using SharpDX.MediaFoundation;
+using SharpDX.Win32;
+using System;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class VideoPlayer : IDisposable
+    {
+        private static MediaSession _session;
+        private static AudioStreamVolume _volumeController;
+        private static PresentationClock _clock;
+
+        // HACK: Need SharpDX to fix this.
+        private static Guid AudioStreamVolumeGuid;
+
+        private static Callback _callback;
+
+        private class Callback : IAsyncCallback
+        {
+            private VideoPlayer _player;
+
+            public Callback(VideoPlayer player)
+            {
+                _player = player;
+            }
+
+            public void Dispose()
+            {
+            }
+
+            public IDisposable Shadow { get; set; }
+            public void Invoke(AsyncResult asyncResultRef)
+            {
+                var ev = _session.EndGetEvent(asyncResultRef);
+
+                // Trigger an "on Video Ended" event here if needed
+
+                if (ev.TypeInfo == MediaEventTypes.SessionTopologyStatus && ev.Get(EventAttributeKeys.TopologyStatus) == TopologyStatus.Ready)
+                    _player.OnTopologyReady();
+
+                _session.BeginGetEvent(this, null);
+            }
+
+            public AsyncCallbackFlags Flags { get; private set; }
+            public WorkQueueId WorkQueueId { get; private set; }
+        }
+
+        private Texture2D _videoCache;
+
+        private void PlatformInitialize()
+        {
+            // The GUID is specified in a GuidAttribute attached to the class
+            AudioStreamVolumeGuid = Guid.Parse(((GuidAttribute)typeof(AudioStreamVolume).GetCustomAttributes(typeof(GuidAttribute), false)[0]).Value);
+
+            MediaManagerState.CheckStartup();
+            MediaFactory.CreateMediaSession(null, out _session);
+
+        }
+
+        private Texture2D PlatformGetTexture()
+        {
+            var sampleGrabber = _currentVideo.SampleGrabber;
+
+            var texData = sampleGrabber.TextureData;
+
+            if (texData == null)
+                return null;
+
+            // NOTE: It's entirely possible that we could lose the d3d context and therefore lose this texture, but it's better than allocating a new texture each call!
+            if (_videoCache == null)
+                _videoCache = new Texture2D(Game.Instance.GraphicsDevice, _currentVideo.Width, _currentVideo.Height, false, SurfaceFormat.Bgr32);
+
+            _videoCache.SetData(texData);
+            
+            return _videoCache;
+        }
+
+        private void PlatformGetState(ref MediaState result)
+        {
+            if (_clock != null)
+            {
+                ClockState state;
+                _clock.GetState(0, out state);
+
+                switch (state)
+                {
+                    case ClockState.Running:
+                        result = MediaState.Playing;
+                        return;
+
+                    case ClockState.Paused:
+                        result = MediaState.Paused;
+                        return;
+                }
+            }
+
+            result = MediaState.Stopped;
+        }
+
+        private void PlatformPause()
+        {
+            _session.Pause();
+        }
+
+        private void PlatformPlay()
+        {
+            // Cleanup the last song first.
+            if (State != MediaState.Stopped)
+            {
+                _session.Stop();
+                _session.ClearTopologies();
+                _session.Close();
+                if (_volumeController != null)
+                {
+                    _volumeController.Dispose();
+                    _volumeController = null;
+                }
+                _clock.Dispose();
+            }
+
+            //create the callback if it hasn't been created yet
+            if (_callback == null)
+            {
+                _callback = new Callback(this);
+                _session.BeginGetEvent(_callback, null);
+            }
+
+            // Set the new song.
+            _session.SetTopology(SessionSetTopologyFlags.Immediate, _currentVideo.Topology);
+
+            // Get the clock.
+            _clock = _session.Clock.QueryInterface<PresentationClock>();
+
+            // Start playing.
+            var varStart = new Variant();
+            _session.Start(null, varStart);
+
+            // we need to dispose of the old texture if we have one
+            if (_videoCache != null)
+                _videoCache.Dispose();
+            // Create cached texture
+            _videoCache = new Texture2D(Game.Instance.GraphicsDevice, _currentVideo.Width, _currentVideo.Height, false, SurfaceFormat.Bgr32);
+        }
+
+        private void PlatformResume()
+        {
+            _session.Start(null, null);
+        }
+
+        private void PlatformStop()
+        {
+            _session.ClearTopologies();
+            _session.Stop();
+            _session.Close();
+            if (_volumeController != null)
+            {
+                _volumeController.Dispose();
+                _volumeController = null;
+            }
+            if (_clock != null)
+            {
+                _clock.Dispose();
+            }
+            _clock = null;
+        }
+
+        private void SetChannelVolumes()
+        {
+            if (_volumeController != null && !_volumeController.IsDisposed)
+            {
+                float volume = _volume;
+                if (IsMuted)
+                    volume = 0.0f;
+
+                for (int i = 0; i < _volumeController.ChannelCount; i++)
+                {
+                    _volumeController.SetChannelVolume(i, volume);
+                }
+            }
+        }
+
+        private void PlatformSetVolume()
+        {
+            if (_volumeController == null)
+                return;
+
+            SetChannelVolumes();
+        }
+
+        private void PlatformSetIsLooped()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void PlatformSetIsMuted()
+        {
+            if (_volumeController == null)
+                return;
+
+            SetChannelVolumes();
+        }
+
+        private TimeSpan PlatformGetPlayPosition()
+        {
+            return TimeSpan.FromTicks(_clock.Time);
+        }
+
+        private void PlatformDispose(bool disposing)
+        {
+            if (_videoCache != null)
+            {
+                _videoCache.Dispose();
+            }
+        }
+
+        private void OnTopologyReady()
+        {
+            if (_session.IsDisposed)
+                return;
+
+            // Get the volume interface.
+            IntPtr volumeObjectPtr;
+            MediaFactory.GetService(_session, MediaServiceKeys.StreamVolume, AudioStreamVolumeGuid, out volumeObjectPtr);
+            _volumeController = CppObject.FromPointer<AudioStreamVolume>(volumeObjectPtr);
+
+            SetChannelVolumes();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/VideoPlayer.cs b/MonoGame.Framework/Media/VideoPlayer.cs
new file mode 100644
index 00000000000..fd4e16341f5
--- /dev/null
+++ b/MonoGame.Framework/Media/VideoPlayer.cs
@@ -0,0 +1,304 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using System.Threading;
+#if WINDOWS_UAP
+using System.Threading.Tasks;
+#endif
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    public sealed partial class VideoPlayer : IDisposable
+    {
+        #region Fields
+
+        private MediaState _state;
+        private Video _currentVideo;
+        private float _volume = 1.0f;
+        private bool _isLooped = false;
+        private bool _isMuted = false;
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets a value that indicates whether the object is disposed.
+        /// </summary>
+        public bool IsDisposed { get; private set; }
+
+        /// <summary>
+        /// Gets a value that indicates whether the player is playing video in a loop.
+        /// </summary>
+        public bool IsLooped
+        {
+            get { return _isLooped; }
+            set
+            {
+                if (_isLooped == value)
+                    return;
+
+                _isLooped = value;
+                PlatformSetIsLooped();
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the muted setting for the video player.
+        /// </summary>
+        public bool IsMuted
+        {
+            get { return _isMuted; }
+            set
+            {
+                if (_isMuted == value)
+                    return;
+
+                _isMuted = value;
+                PlatformSetIsMuted();
+            }
+        }
+
+        /// <summary>
+        /// Gets the play position within the currently playing video.
+        /// </summary>
+        public TimeSpan PlayPosition
+        {
+            get
+            {
+                if (_currentVideo == null || State == MediaState.Stopped)
+                    return TimeSpan.Zero;
+
+                return PlatformGetPlayPosition();
+            }
+        }
+
+        /// <summary>
+        /// Gets the media playback state, MediaState.
+        /// </summary>
+        public MediaState State
+        { 
+            get
+            {
+                // Give the platform code a chance to update 
+                // the playback state before we return the result.
+                PlatformGetState(ref _state);
+                return _state;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Video that is currently playing.
+        /// </summary>
+        public Video Video { get { return _currentVideo; } }
+
+        /// <summary>
+        /// Video player volume, from 0.0f (silence) to 1.0f (full volume relative to the current device volume).
+        /// </summary>
+        public float Volume
+        {
+            get { return _volume; }
+            
+            set
+            {
+                if (value < 0.0f || value > 1.0f)
+                    throw new ArgumentOutOfRangeException();
+
+                _volume = value;
+
+                if (_currentVideo != null)
+                    PlatformSetVolume();
+            }
+        }
+
+        #endregion
+
+        #region Public API
+
+        public VideoPlayer()
+        {
+            _state = MediaState.Stopped;
+
+            PlatformInitialize();
+        }
+
+        /// <summary>
+        /// Retrieves a Texture2D containing the current frame of video being played.
+        /// </summary>
+        /// <returns>The current frame of video.</returns>
+        /// <exception cref="InvalidOperationException">Thrown if no video is set on the player</exception>
+        /// <exception cref="InvalidOperationException">Thrown if the platform was unable to get a texture in a reasonable amount of time. Often the platform specific media code is running
+        /// in a different thread or process. Note: This may be a change from XNA behaviour</exception>
+        public Texture2D GetTexture()
+        {
+            if (_currentVideo == null)
+                throw new InvalidOperationException("Operation is not valid due to the current state of the object");
+
+            //XNA never returns a null texture
+            const int retries = 5;
+            const int sleepTimeFactor = 50;
+            Texture2D texture=null;
+
+            for (int i = 0; i < retries; i++)
+            {
+                texture = PlatformGetTexture();
+                if (texture != null)
+                {
+                    break;
+                }
+                var sleepTime = i*sleepTimeFactor;
+                Debug.WriteLine("PlatformGetTexture returned null ({0}) sleeping for {1} ms", i + 1, sleepTime);
+#if WINDOWS_UAP
+                Task.Delay(sleepTime).Wait();
+#else
+                Thread.Sleep(sleepTime); //Sleep for longer and longer times
+#endif
+            }
+            if (texture == null)
+            {
+                throw new InvalidOperationException("Platform returned a null texture");
+            }
+
+            return texture;
+        }
+
+        /// <summary>
+        /// Pauses the currently playing video.
+        /// </summary>
+        public void Pause()
+        {
+            if (_currentVideo == null)
+                return;
+
+            PlatformPause();
+
+            _state = MediaState.Paused;
+        }
+
+        /// <summary>
+        /// Plays a Video.
+        /// </summary>
+        /// <param name="video">Video to play.</param>
+        public void Play(Video video)
+        {
+            if (video == null)
+                throw new ArgumentNullException("video is null.");
+
+            if (_currentVideo == video)
+            {
+                var state = State;
+							
+                // No work to do if we're already
+                // playing this video.
+                if (state == MediaState.Playing)
+                    return;
+
+                // If we try to Play the same video
+                // from a paused state, just resume it instead.
+                if (state == MediaState.Paused)
+                {
+                    PlatformResume();
+                    return;
+                }
+            }
+            
+            _currentVideo = video;
+
+            PlatformPlay();
+
+            _state = MediaState.Playing;
+
+            // XNA doesn't return until the video is playing
+            const int retries = 5;
+            const int sleepTimeFactor = 50;
+
+            for (int i = 0; i < retries; i++)
+            {
+                if (State == MediaState.Playing )
+                {
+                    break;
+                }
+                var sleepTime = i*sleepTimeFactor;
+                Debug.WriteLine("State != MediaState.Playing ({0}) sleeping for {1} ms", i + 1, sleepTime);
+#if WINDOWS_UAP
+                Task.Delay(sleepTime).Wait();
+#else
+                Thread.Sleep(sleepTime); //Sleep for longer and longer times
+#endif
+            }
+            if (State != MediaState.Playing )
+            {
+                //We timed out - attempt to stop to fix any bad state
+                Stop();
+                throw new InvalidOperationException("cannot start video"); 
+            }
+        }
+
+        /// <summary>
+        /// Resumes a paused video.
+        /// </summary>
+        public void Resume()
+        {
+            if (_currentVideo == null)
+                return;
+
+            var state = State;
+
+            // No work to do if we're already playing
+            if (state == MediaState.Playing)
+                return;
+
+            if (state == MediaState.Stopped)
+            {
+                PlatformPlay();
+                return;
+            }
+
+            PlatformResume();
+
+            _state = MediaState.Playing;
+        }
+
+        /// <summary>
+        /// Stops playing a video.
+        /// </summary>
+        public void Stop()
+        {
+            if (_currentVideo == null)
+                return;
+
+            PlatformStop();
+
+            _state = MediaState.Stopped;
+        }
+
+        #endregion
+
+        #region IDisposable Implementation
+
+        /// <summary>
+        /// Immediately releases the unmanaged resources used by this object.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        private void Dispose(bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                PlatformDispose(disposing);
+                IsDisposed = true;
+            }
+        }
+
+        #endregion
+
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Media/VideoSampleGrabber.cs b/MonoGame.Framework/Media/VideoSampleGrabber.cs
new file mode 100644
index 00000000000..57fd07651e0
--- /dev/null
+++ b/MonoGame.Framework/Media/VideoSampleGrabber.cs
@@ -0,0 +1,54 @@
+using SharpDX.MediaFoundation;
+using System;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Xna.Framework.Media
+{
+    internal class VideoSampleGrabber : SharpDX.CallbackBase, SampleGrabberSinkCallback
+    {
+        internal byte[] TextureData { get; private set; }
+
+        public void OnProcessSample(Guid guidMajorMediaType, int dwSampleFlags, long llSampleTime, long llSampleDuration, IntPtr sampleBufferRef, int dwSampleSize)
+        {
+            if (TextureData == null || TextureData.Length != dwSampleSize)
+                TextureData = new byte[dwSampleSize];
+
+            Marshal.Copy(sampleBufferRef, TextureData, 0, dwSampleSize);
+        }
+
+        public void OnSetPresentationClock(PresentationClock presentationClockRef)
+        {
+
+        }
+
+        public void OnShutdown()
+        {
+
+        }
+
+        public void OnClockPause(long systemTime)
+        {
+
+        }
+
+        public void OnClockRestart(long systemTime)
+        {
+
+        }
+
+        public void OnClockSetRate(long systemTime, float flRate)
+        {
+
+        }
+
+        public void OnClockStart(long systemTime, long llClockStartOffset)
+        {
+
+        }
+
+        public void OnClockStop(long hnsSystemTime)
+        {
+
+        }
+    }
+}
diff --git a/MonoGame.Framework/Media/VideoSoundtrackType.cs b/MonoGame.Framework/Media/VideoSoundtrackType.cs
new file mode 100644
index 00000000000..7de4c73215f
--- /dev/null
+++ b/MonoGame.Framework/Media/VideoSoundtrackType.cs
@@ -0,0 +1,27 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Media
+{
+    /// <summary>
+    /// Type of sounds in a video
+    /// </summary>
+    public enum VideoSoundtrackType
+    {
+        /// <summary>
+        /// This video contains only music.
+        /// </summary>
+        Music,
+
+        /// <summary>
+        /// This video contains only dialog.
+        /// </summary>
+        Dialog,
+
+        /// <summary>
+        /// This video contains music and dialog.
+        /// </summary>
+        MusicAndDialog,
+    }
+}
diff --git a/MonoGame.Framework/Microsoft/Devices/Sensors/AccelerometerFailedException.cs b/MonoGame.Framework/Microsoft/Devices/Sensors/AccelerometerFailedException.cs
new file mode 100644
index 00000000000..965f72be7e1
--- /dev/null
+++ b/MonoGame.Framework/Microsoft/Devices/Sensors/AccelerometerFailedException.cs
@@ -0,0 +1,23 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Devices.Sensors
+{
+    /// <summary>
+    /// The exception that may be thrown during a call to Start() or Stop(). The Message field describes the reason for the exception and the ErrorId field contains the error code from the underlying native code implementation of the accelerometer framework.
+    /// </summary>
+    public class AccelerometerFailedException : SensorFailedException
+    {
+        /// <summary>
+        /// Initializes a new instance of AccelerometerFailedException
+        /// </summary>
+        /// <param name="message">The descriptive reason for the exception</param>
+        /// <param name="errorId">The native error code that caused the exception</param>
+        internal AccelerometerFailedException(string message, int errorId)
+            : base(message)
+        {
+            ErrorId = errorId;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Microsoft/Devices/Sensors/AccelerometerReading.cs b/MonoGame.Framework/Microsoft/Devices/Sensors/AccelerometerReading.cs
new file mode 100644
index 00000000000..2a0d60ef669
--- /dev/null
+++ b/MonoGame.Framework/Microsoft/Devices/Sensors/AccelerometerReading.cs
@@ -0,0 +1,16 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework;
+
+namespace Microsoft.Devices.Sensors
+{
+	public struct AccelerometerReading : ISensorReading
+	{
+		public Vector3 Acceleration { get; internal set; }
+		public DateTimeOffset Timestamp { get; internal set; }
+	}
+}
+
diff --git a/MonoGame.Framework/Microsoft/Devices/Sensors/CalibrationEventArgs.cs b/MonoGame.Framework/Microsoft/Devices/Sensors/CalibrationEventArgs.cs
new file mode 100644
index 00000000000..dcad6786f55
--- /dev/null
+++ b/MonoGame.Framework/Microsoft/Devices/Sensors/CalibrationEventArgs.cs
@@ -0,0 +1,24 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Devices.Sensors
+{
+    /// <summary>
+    /// Provides data for Calibrate and events.
+    /// </summary>
+    public class CalibrationEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Initializes a new instance of the CalibrationEventArgs class.
+        /// </summary>
+        /// <remarks>
+        /// Obtain a CalibrationEventArgs object by implementing a handler for the Compass.Calibrate event.
+        /// </remarks>
+        public CalibrationEventArgs()
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Microsoft/Devices/Sensors/CompassReading.cs b/MonoGame.Framework/Microsoft/Devices/Sensors/CompassReading.cs
new file mode 100644
index 00000000000..e51cead7b1c
--- /dev/null
+++ b/MonoGame.Framework/Microsoft/Devices/Sensors/CompassReading.cs
@@ -0,0 +1,18 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework;
+
+namespace Microsoft.Devices.Sensors
+{
+    public struct CompassReading : ISensorReading
+    {
+        public double HeadingAccuracy { get; internal set; }
+        public double MagneticHeading { get; internal set; }
+        public Vector3 MagnetometerReading { get; internal set; }
+        public DateTimeOffset Timestamp { get; internal set; }
+        public double TrueHeading { get; internal set; }
+    }
+}
diff --git a/MonoGame.Framework/Microsoft/Devices/Sensors/ISensorReading.cs b/MonoGame.Framework/Microsoft/Devices/Sensors/ISensorReading.cs
new file mode 100644
index 00000000000..71932566b02
--- /dev/null
+++ b/MonoGame.Framework/Microsoft/Devices/Sensors/ISensorReading.cs
@@ -0,0 +1,14 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Devices.Sensors
+{
+	public interface ISensorReading
+	{
+		DateTimeOffset Timestamp { get; }
+	}
+}
+
diff --git a/MonoGame.Framework/Microsoft/Devices/Sensors/SensorBase.cs b/MonoGame.Framework/Microsoft/Devices/Sensors/SensorBase.cs
new file mode 100644
index 00000000000..d323e309ed2
--- /dev/null
+++ b/MonoGame.Framework/Microsoft/Devices/Sensors/SensorBase.cs
@@ -0,0 +1,88 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using Microsoft.Xna.Framework;
+using System;
+
+namespace Microsoft.Devices.Sensors
+{
+	public abstract class SensorBase<TSensorReading> : IDisposable
+		where TSensorReading : ISensorReading
+	{
+#if IOS
+        [CLSCompliant(false)]
+        protected static readonly CoreMotion.CMMotionManager motionManager = new CoreMotion.CMMotionManager();
+#endif
+        bool disposed;
+		private TimeSpan timeBetweenUpdates;
+	    private TSensorReading currentValue;
+        private SensorReadingEventArgs<TSensorReading> eventArgs = new SensorReadingEventArgs<TSensorReading>(default(TSensorReading));
+
+		public TSensorReading CurrentValue 
+        {
+            get { return currentValue; }
+		    protected set
+		    {
+		        currentValue = value;
+
+                var handler = CurrentValueChanged;
+
+                if (handler != null)
+                {
+                    eventArgs.SensorReading = value;
+                    handler(this, eventArgs);
+                }
+		    }
+		}
+		public bool IsDataValid { get; protected set; }
+		public TimeSpan TimeBetweenUpdates
+		{
+			get { return this.timeBetweenUpdates; }
+			set
+			{
+				if (this.timeBetweenUpdates != value)
+				{
+					this.timeBetweenUpdates = value;
+					EventHelpers.Raise(this, TimeBetweenUpdatesChanged, EventArgs.Empty);
+				}
+			}
+		}
+
+		public event EventHandler<SensorReadingEventArgs<TSensorReading>> CurrentValueChanged;
+		protected event EventHandler<EventArgs> TimeBetweenUpdatesChanged;
+        protected bool IsDisposed { get { return disposed; } }
+
+		public SensorBase()
+		{
+			this.TimeBetweenUpdates = TimeSpan.FromMilliseconds(2);
+		}
+
+        ~SensorBase()
+        {
+            Dispose(false);
+        }
+
+		public void Dispose()
+        {
+            if (disposed)
+                throw new ObjectDisposedException(GetType().Name);
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Derived classes override this method to dispose of managed and unmanaged resources.
+        /// </summary>
+        /// <param name="disposing">True if unmanaged resources are to be disposed.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            disposed = true;
+        }
+
+		public abstract void Start();
+
+		public abstract void Stop();
+	}
+}
+
diff --git a/MonoGame.Framework/Microsoft/Devices/Sensors/SensorFailedException.cs b/MonoGame.Framework/Microsoft/Devices/Sensors/SensorFailedException.cs
new file mode 100644
index 00000000000..443675e1960
--- /dev/null
+++ b/MonoGame.Framework/Microsoft/Devices/Sensors/SensorFailedException.cs
@@ -0,0 +1,19 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Devices.Sensors
+{
+	public class SensorFailedException : Exception
+	{
+		public int ErrorId { get; protected set; }
+
+        internal SensorFailedException(string message)
+            : base(message)
+        {
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Microsoft/Devices/Sensors/SensorReadingEventArgs.cs b/MonoGame.Framework/Microsoft/Devices/Sensors/SensorReadingEventArgs.cs
new file mode 100644
index 00000000000..fd62143e04b
--- /dev/null
+++ b/MonoGame.Framework/Microsoft/Devices/Sensors/SensorReadingEventArgs.cs
@@ -0,0 +1,20 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Devices.Sensors
+{
+	public class SensorReadingEventArgs<T> : EventArgs
+		where T : ISensorReading
+	{
+		public T SensorReading { get; set; }
+
+		public SensorReadingEventArgs(T sensorReading)
+		{
+			this.SensorReading = sensorReading;
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Microsoft/Devices/Sensors/SensorState.cs b/MonoGame.Framework/Microsoft/Devices/Sensors/SensorState.cs
new file mode 100644
index 00000000000..acdcf8319db
--- /dev/null
+++ b/MonoGame.Framework/Microsoft/Devices/Sensors/SensorState.cs
@@ -0,0 +1,19 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Devices.Sensors
+{
+	public enum SensorState
+	{
+		NotSupported,
+		Ready,
+		Initializing,
+		NoData,
+		NoPermissions,
+		Disabled
+	}
+}
+
diff --git a/MonoGame.Framework/MonoGame.Framework.Net.WindowsUniversal.project.json b/MonoGame.Framework/MonoGame.Framework.Net.WindowsUniversal.project.json
new file mode 100644
index 00000000000..c5949392705
--- /dev/null
+++ b/MonoGame.Framework/MonoGame.Framework.Net.WindowsUniversal.project.json
@@ -0,0 +1,16 @@
+{
+  "dependencies": {
+    "Microsoft.NETCore.UniversalWindowsPlatform": "5.0.0"
+  },
+  "frameworks": {
+    "uap10.0": {}
+  },
+  "runtimes": {
+    "win10-arm": {},
+    "win10-arm-aot": {},
+    "win10-x86": {},
+    "win10-x86-aot": {},
+    "win10-x64": {},
+    "win10-x64-aot": {}
+  }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/MonoGame.Framework.WindowsUniversal.project.json b/MonoGame.Framework/MonoGame.Framework.WindowsUniversal.project.json
new file mode 100644
index 00000000000..c5949392705
--- /dev/null
+++ b/MonoGame.Framework/MonoGame.Framework.WindowsUniversal.project.json
@@ -0,0 +1,16 @@
+{
+  "dependencies": {
+    "Microsoft.NETCore.UniversalWindowsPlatform": "5.0.0"
+  },
+  "frameworks": {
+    "uap10.0": {}
+  },
+  "runtimes": {
+    "win10-arm": {},
+    "win10-arm-aot": {},
+    "win10-x86": {},
+    "win10-x86-aot": {},
+    "win10-x64": {},
+    "win10-x64-aot": {}
+  }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/MonoGame.bmp b/MonoGame.Framework/MonoGame.bmp
new file mode 100644
index 00000000000..2b481653e24
Binary files /dev/null and b/MonoGame.Framework/MonoGame.bmp differ
diff --git a/MonoGame.Framework/NamespaceDocs.cs b/MonoGame.Framework/NamespaceDocs.cs
new file mode 100644
index 00000000000..a8c2f2f2548
--- /dev/null
+++ b/MonoGame.Framework/NamespaceDocs.cs
@@ -0,0 +1,36 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework.Input
+{
+    /// <summary>
+    /// Provides functionality to handle input from keyboards, mice, gamepads, etc.
+    /// </summary>
+    [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    class NamespaceDoc
+    {
+    }
+}
+
+namespace Microsoft.Xna.Framework.Audio
+{
+    /// <summary>
+    /// Support for playing sound effects and XACT audio.
+    /// </summary>
+    [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    class NamespaceDoc
+    {
+    }
+}
+
+namespace Microsoft.Xna.Framework.Content
+{
+    /// <summary>
+    /// The runtime support for loading content pipeline content.
+    /// </summary>
+    [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    class NamespaceDoc
+    {
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Net/AvailableNetworkSession.cs b/MonoGame.Framework/Net/AvailableNetworkSession.cs
new file mode 100644
index 00000000000..dbe02dcc9f0
--- /dev/null
+++ b/MonoGame.Framework/Net/AvailableNetworkSession.cs
@@ -0,0 +1,136 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License 
+
+#region Using clause
+using System;
+using System.Net;
+
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+	public sealed class AvailableNetworkSession
+	{
+
+		public AvailableNetworkSession ()
+		{
+			_QualityOfService = new QualityOfService();
+		}
+		
+		int _currentGameCount;
+		public int CurrentGamerCount 
+		{ 
+			get
+			{
+				return _currentGameCount;
+			}
+			
+			internal set { _currentGameCount = value; }
+		}
+		
+		string _hostGamertag;
+		public string HostGamertag 
+		{ 
+			get
+			{
+				return _hostGamertag;
+			}
+			
+			internal set { _hostGamertag = value; }
+		}
+		
+		int _openPrivateGamerSlots;
+		public int OpenPrivateGamerSlots 
+		{ 
+			get
+			{
+				return _openPrivateGamerSlots;
+			}
+			
+			internal set { _openPrivateGamerSlots = value; }			
+		}
+		
+		int _openPublicGamerSlots; 
+		public int OpenPublicGamerSlots 
+		{ 
+			get
+			{
+				return _openPublicGamerSlots;
+			}
+			internal set { _openPublicGamerSlots = value; }			
+		}
+		
+		private QualityOfService _QualityOfService;
+		public QualityOfService QualityOfService 
+		{ 
+			get
+			{
+				return _QualityOfService;
+			}
+			internal set { _QualityOfService = value; }			
+		}
+		
+		NetworkSessionProperties _sessionProperties;
+		public NetworkSessionProperties SessionProperties 
+		{ 
+			get
+			{
+				return _sessionProperties;
+			}
+			internal set { _sessionProperties = value; }			
+		}
+		
+		IPEndPoint _endPoint;
+		internal IPEndPoint EndPoint 
+		{
+			get { return _endPoint; }
+			set { _endPoint = value;}
+		}
+        IPEndPoint _internalendPoint;
+
+        internal IPEndPoint InternalEndpont
+        {
+            get { return _internalendPoint; }
+            set { _internalendPoint = value; }
+        }
+
+        internal NetworkSessionType SessionType { get; set; }
+    }
+}
diff --git a/MonoGame.Framework/Net/AvailableNetworkSessionCollection.cs b/MonoGame.Framework/Net/AvailableNetworkSessionCollection.cs
new file mode 100644
index 00000000000..d780d5e6f95
--- /dev/null
+++ b/MonoGame.Framework/Net/AvailableNetworkSessionCollection.cs
@@ -0,0 +1,62 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License 
+
+#region Using clause
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+	public sealed class AvailableNetworkSessionCollection : ReadOnlyCollection<AvailableNetworkSession>, IDisposable
+	{
+		public AvailableNetworkSessionCollection( IList<AvailableNetworkSession> list ) : base(list)
+		{
+		}
+		
+		public void Dispose()
+		{
+			
+		}
+	}
+}
diff --git a/MonoGame.Framework/Net/CommandEvent.cs b/MonoGame.Framework/Net/CommandEvent.cs
new file mode 100644
index 00000000000..a160f7e27a2
--- /dev/null
+++ b/MonoGame.Framework/Net/CommandEvent.cs
@@ -0,0 +1,34 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Net
+{
+	internal class CommandEvent
+	{
+		CommandEventType command;
+		object commandObject;
+		
+		public CommandEvent (CommandEventType command, object commandObject)
+		{
+			this.command = command;
+			this.commandObject = commandObject;
+		}
+		
+		public CommandEvent (ICommand command)
+		{
+			this.command = command.Command;
+			this.commandObject = command;
+		}		
+		
+		public CommandEventType Command
+		{
+			get { return command; }
+			
+		}
+		
+		public object CommandObject
+		{
+			get { return commandObject; }
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Net/CommandEventType.cs b/MonoGame.Framework/Net/CommandEventType.cs
new file mode 100644
index 00000000000..83995384a36
--- /dev/null
+++ b/MonoGame.Framework/Net/CommandEventType.cs
@@ -0,0 +1,15 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Net
+{
+	public enum CommandEventType
+	{
+		GamerJoined,
+		GamerLeft,
+		SessionStateChange,
+		SendData,
+		ReceiveData,
+		GamerStateChange,
+	}
+}
+
diff --git a/MonoGame.Framework/Net/CommandGamerJoined.cs b/MonoGame.Framework/Net/CommandGamerJoined.cs
new file mode 100644
index 00000000000..b20c22b0cfd
--- /dev/null
+++ b/MonoGame.Framework/Net/CommandGamerJoined.cs
@@ -0,0 +1,64 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Net
+{
+	internal class CommandGamerJoined : ICommand
+	{
+		int gamerInternalIndex = -1;
+		internal long remoteUniqueIdentifier = -1;
+		GamerStates states;
+		string gamerTag = string.Empty;
+		string displayName = string.Empty;
+		
+		public CommandGamerJoined (int internalIndex, bool isHost, bool isLocal)
+		{
+			gamerInternalIndex = internalIndex;
+			
+			if (isHost)
+				states = states | GamerStates.Host;
+			if (isLocal)
+				states = states | GamerStates.Local;
+			
+		}
+		
+		public CommandGamerJoined (long uniqueIndentifier)
+		{
+			this.remoteUniqueIdentifier = uniqueIndentifier;
+			
+		}
+		
+		public string DisplayName {
+			get {
+				return displayName;
+			}
+			set {
+				displayName = value;
+			}
+		}	
+		
+		public string GamerTag {
+			get {
+				return gamerTag;
+			}
+			set {
+				gamerTag = value;
+			}
+		}	
+		
+		public GamerStates State
+		{
+			get { return states; }
+			set { states = value; }
+		}
+		
+		public int InternalIndex
+		{
+			get { return gamerInternalIndex; }
+		}
+		
+		public CommandEventType Command {
+			get { return CommandEventType.GamerJoined; }
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Net/CommandGamerLeft.cs b/MonoGame.Framework/Net/CommandGamerLeft.cs
new file mode 100644
index 00000000000..0a52e2f752a
--- /dev/null
+++ b/MonoGame.Framework/Net/CommandGamerLeft.cs
@@ -0,0 +1,32 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Net
+{
+	internal class CommandGamerLeft : ICommand
+	{
+		int gamerInternalIndex = -1;
+		internal long remoteUniqueIdentifier = -1;
+		
+		public CommandGamerLeft (int internalIndex)
+		{
+			gamerInternalIndex = internalIndex;
+			
+		}
+		
+		public CommandGamerLeft (long uniqueIndentifier)
+		{
+			this.remoteUniqueIdentifier = uniqueIndentifier;
+			
+		}		
+		
+		public int InternalIndex
+		{
+			get { return gamerInternalIndex; }
+		}
+		
+		public CommandEventType Command {
+			get { return CommandEventType.GamerLeft; }
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Net/CommandGamerStateChange.cs b/MonoGame.Framework/Net/CommandGamerStateChange.cs
new file mode 100644
index 00000000000..df2a5f3bac4
--- /dev/null
+++ b/MonoGame.Framework/Net/CommandGamerStateChange.cs
@@ -0,0 +1,38 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Net
+{
+	internal class CommandGamerStateChange : ICommand
+	{
+		
+		GamerStates newState;
+		GamerStates oldState;
+		NetworkGamer gamer;
+		
+		public CommandGamerStateChange (NetworkGamer gamer)
+		{
+			this.gamer = gamer;
+			this.newState = gamer.State;
+			this.oldState = gamer.OldState;
+		}
+		
+		public NetworkGamer Gamer 
+		{
+			get { return gamer; }
+		}
+		public GamerStates NewState
+		{
+			get { return newState; }
+		}
+		
+		public GamerStates OldState
+		{
+			get { return oldState; }
+		}
+		
+		public CommandEventType Command {
+			get { return CommandEventType.GamerStateChange; }
+		}		
+	}
+}
+
diff --git a/MonoGame.Framework/Net/CommandReceiveData.cs b/MonoGame.Framework/Net/CommandReceiveData.cs
new file mode 100644
index 00000000000..da3d3ef4251
--- /dev/null
+++ b/MonoGame.Framework/Net/CommandReceiveData.cs
@@ -0,0 +1,23 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Net
+{
+	internal class CommandReceiveData : ICommand
+	{
+		internal byte[] data;
+		internal long remoteUniqueIdentifier = -1;
+		internal NetworkGamer gamer;
+		
+		public CommandReceiveData (long remoteUniqueIdentifier, byte[] data)
+		{
+			this.remoteUniqueIdentifier = remoteUniqueIdentifier;
+			this.data = data;
+				
+		}
+		
+		public CommandEventType Command {
+			get { return CommandEventType.ReceiveData; }
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Net/CommandSendData.cs b/MonoGame.Framework/Net/CommandSendData.cs
new file mode 100644
index 00000000000..25bc776e141
--- /dev/null
+++ b/MonoGame.Framework/Net/CommandSendData.cs
@@ -0,0 +1,34 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Net
+{
+	internal class CommandSendData : ICommand
+	{
+		internal int gamerInternalIndex = -1;
+		internal byte[] data;
+		internal SendDataOptions options;
+		internal int offset;
+		internal int count;
+		internal NetworkGamer gamer;
+		internal LocalNetworkGamer sender;
+		
+		public CommandSendData (byte[] data, int offset, int count, SendDataOptions options, NetworkGamer gamer, LocalNetworkGamer sender)
+		{
+			if (gamer != null)
+				gamerInternalIndex = gamer.Id;
+			this.data = new byte[count];
+			Array.Copy(data, offset, this.data, 0, count);
+			this.offset = offset;
+			this.count = count;
+			this.options = options;
+			this.gamer = gamer;
+			this.sender = sender;
+				
+		}
+		
+		public CommandEventType Command {
+			get { return CommandEventType.SendData; }
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Net/CommandSessionStateChange.cs b/MonoGame.Framework/Net/CommandSessionStateChange.cs
new file mode 100644
index 00000000000..32f1407c090
--- /dev/null
+++ b/MonoGame.Framework/Net/CommandSessionStateChange.cs
@@ -0,0 +1,32 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Net
+{
+	internal class CommandSessionStateChange : ICommand
+	{
+		
+		NetworkSessionState newState;
+		NetworkSessionState oldState;
+		
+		public CommandSessionStateChange (NetworkSessionState newState, NetworkSessionState oldState)
+		{
+			this.newState = newState;
+			this.oldState = oldState;
+		}
+		
+		public NetworkSessionState NewState
+		{
+			get { return newState; }
+		}
+		
+		public NetworkSessionState OldState
+		{
+			get { return oldState; }
+		}
+		
+		public CommandEventType Command {
+			get { return CommandEventType.SessionStateChange; }
+		}		
+	}
+}
+
diff --git a/MonoGame.Framework/Net/GamerStates.cs b/MonoGame.Framework/Net/GamerStates.cs
new file mode 100644
index 00000000000..1dc117a1b4c
--- /dev/null
+++ b/MonoGame.Framework/Net/GamerStates.cs
@@ -0,0 +1,18 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Net
+{
+	[Flags]
+	public enum GamerStates
+	{
+		Local 		= 0x000001,
+		Host 		= 0x000010,
+		HasVoice 	= 0x000100,
+		Guest 		= 0x001000,
+		MutedByLocalUser = 0x010000,
+		PrivateSlot	=  0x100000,
+		Ready		= 0x1000000,
+		
+	}
+}
+
diff --git a/MonoGame.Framework/Net/ICommand.cs b/MonoGame.Framework/Net/ICommand.cs
new file mode 100644
index 00000000000..4af67bc0d04
--- /dev/null
+++ b/MonoGame.Framework/Net/ICommand.cs
@@ -0,0 +1,11 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Net
+{
+	internal interface ICommand
+	{
+		
+		CommandEventType Command { get; }
+	}
+}
+
diff --git a/MonoGame.Framework/Net/LocalNetworkGamer.cs b/MonoGame.Framework/Net/LocalNetworkGamer.cs
new file mode 100644
index 00000000000..e047d0f714c
--- /dev/null
+++ b/MonoGame.Framework/Net/LocalNetworkGamer.cs
@@ -0,0 +1,224 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+#region Using clause
+using System;
+using System.Collections.Generic;
+
+using Microsoft.Xna.Framework.GamerServices;
+
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+	public sealed class LocalNetworkGamer : NetworkGamer
+	{
+
+		private SignedInGamer sig;
+		internal Queue<CommandReceiveData> receivedData;
+		
+		public LocalNetworkGamer () : base(null, 0, 0)
+		{
+			sig = new SignedInGamer ();
+			receivedData = new Queue<CommandReceiveData>();
+		}
+
+		public LocalNetworkGamer (NetworkSession session,byte id,GamerStates state)
+			: base(session, id, state | GamerStates.Local)
+		{
+			sig = new SignedInGamer ();
+			receivedData = new Queue<CommandReceiveData>();
+		}
+
+        /*
+		public void EnableSendVoice (
+			NetworkGamer remoteGamer, 
+			bool enable)
+		{
+			throw new NotImplementedException ();
+		}
+        */
+
+		public int ReceiveData (
+			byte[] data, 
+			int offset,
+			out NetworkGamer sender)
+		{
+			if (data == null)
+				throw new ArgumentNullException("data");
+			
+			if (receivedData.Count <= 0) {
+				sender = null;
+				return 0;
+			}
+			
+			lock (receivedData) {
+
+				CommandReceiveData crd;
+				
+				// we will peek at the value first to see if we can process it
+				crd = (CommandReceiveData)receivedData.Peek();
+				
+				if (offset + crd.data.Length > data.Length)
+					throw new ArgumentOutOfRangeException("data","The length + offset is greater than parameter can hold.");
+				
+				// no exception thrown yet so let's process it
+				// take it off the queue
+				receivedData.Dequeue();
+				
+				Array.Copy(crd.data, offset, data, 0, data.Length);
+				sender = crd.gamer;
+				return data.Length;			
+			}
+			
+		}
+
+		public int ReceiveData (
+			byte[] data,
+			out NetworkGamer sender)
+		{
+			return ReceiveData(data, 0, out sender);
+		}
+
+		public int ReceiveData (
+			PacketReader data,
+			out NetworkGamer sender)
+		{
+			lock (receivedData) {
+				if (receivedData.Count >= 0) {
+					data.Reset(0);
+
+					// take it off the queue
+					CommandReceiveData crd = (CommandReceiveData)receivedData.Dequeue();
+					
+					// lets make sure that we can handle the data
+					if (data.Length < crd.data.Length) {
+						data.Reset(crd.data.Length);
+					}
+
+					Array.Copy(crd.data, data.Data, data.Length);
+					sender = crd.gamer;
+					return data.Length;	
+					
+				}
+				else {
+					sender = null;
+					return 0;
+				}
+				
+			}
+		}
+
+		public void SendData (
+			byte[] data,
+			int offset,
+			int count,
+			SendDataOptions options)
+		{
+			CommandEvent cme = new CommandEvent(new CommandSendData(data, offset, count, options, null, this ));
+			Session.commandQueue.Enqueue(cme);
+		}
+
+		public void SendData (
+			byte[] data,
+			int offset,
+			int count,
+			SendDataOptions options,
+			NetworkGamer recipient)
+		{
+			CommandEvent cme = new CommandEvent(new CommandSendData(data, offset, count, options, recipient,this ));
+			Session.commandQueue.Enqueue(cme);
+		}
+
+		public void SendData (
+			byte[] data,
+			SendDataOptions options)
+		{
+			CommandEvent cme = new CommandEvent(new CommandSendData(data, 0, data.Length, options, null, this ));
+			Session.commandQueue.Enqueue(cme);
+		}
+
+		public void SendData (
+			byte[] data,
+			SendDataOptions options,
+			NetworkGamer recipient)
+		{
+			CommandEvent cme = new CommandEvent(new CommandSendData(data, 0, data.Length, options, recipient, this ));
+			Session.commandQueue.Enqueue(cme);
+		}
+
+		public void SendData (
+			PacketWriter data,
+			SendDataOptions options)
+		{
+			SendData(data.Data, 0, data.Length, options, null);
+			data.Reset();
+		}
+
+		public void SendData (
+			PacketWriter data,
+			SendDataOptions options,
+			NetworkGamer recipient)
+		{
+			SendData(data.Data, 0, data.Length, options, recipient);
+			data.Reset();
+		}
+
+		public bool IsDataAvailable { 
+			get {
+				lock (receivedData) {
+					return receivedData.Count > 0;
+				}
+			}
+		}
+
+		public SignedInGamer SignedInGamer { 
+			get {
+				return sig;
+			}
+			
+			internal set {
+				sig = value;
+				DisplayName = sig.DisplayName;
+				Gamertag = sig.Gamertag;
+			}
+		}
+	}
+}
diff --git a/MonoGame.Framework/Net/MonoGamerPeer.cs b/MonoGame.Framework/Net/MonoGamerPeer.cs
new file mode 100644
index 00000000000..21f6d0352c8
--- /dev/null
+++ b/MonoGame.Framework/Net/MonoGamerPeer.cs
@@ -0,0 +1,751 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+
+using System.Threading;
+using System.ComponentModel;
+
+using Lidgren.Network;
+
+namespace Microsoft.Xna.Framework.Net
+{
+    public class MonoGameNetworkConfiguration
+    {
+        public static IPAddress Broadcast = IPAddress.None;
+    }
+
+	internal class MonoGamerPeer
+	{
+		private BackgroundWorker MGServerWorker = new BackgroundWorker ();
+		bool done = false;
+		NetServer peer;
+		NetworkSession session;
+		AvailableNetworkSession availableSession;
+		string myLocalAddress = string.Empty;
+		IPEndPoint myLocalEndPoint = null;
+		Dictionary<long, NetConnection> pendingGamers = new Dictionary<long, NetConnection> ();
+		//Dictionary<long, NetConnection> connectedGamers = new Dictionary<long, NetConnection>();
+		bool online = false;
+		private static int port = 3074;
+		private static IPEndPoint m_masterServer;
+		private static int masterserverport = 6000;
+		private static string masterServer = "monolive.servegame.com";
+		internal static string applicationIdentifier = "monogame";
+		
+		static MonoGamerPeer()
+		{
+			// This code looks up the Guid for the host app , this is used to identify the
+			// application on the network . We use the Guid as that is unique to that application.			
+			var assembly = System.Reflection.Assembly.GetAssembly(Game.Instance.GetType());
+			if (assembly != null)
+			{
+				object[] objects = assembly.GetCustomAttributes(typeof(System.Runtime.InteropServices.GuidAttribute), false);
+	  			if (objects.Length > 0)
+	 			{
+	   				applicationIdentifier = ((System.Runtime.InteropServices.GuidAttribute)objects[0]).Value;
+	 			} 			
+			}
+		}
+
+		public MonoGamerPeer (NetworkSession session,AvailableNetworkSession availableSession)
+			{            
+			this.session = session;
+			this.online = this.session.SessionType == NetworkSessionType.PlayerMatch;
+			this.availableSession = availableSession;            
+			//MGServerWorker.WorkerReportsProgress = true;
+			MGServerWorker.WorkerSupportsCancellation = true;
+			MGServerWorker.DoWork += new DoWorkEventHandler (MGServer_DoWork);
+			MGServerWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler (MGServer_RunWorkerCompleted);
+			MGServerWorker.RunWorkerAsync ();
+
+			HookEvents ();
+		}
+
+		private void HookEvents ()
+		{
+			session.GameEnded += HandleSessionStateChanged;
+
+			session.SessionEnded += HandleSessionStateChanged;
+
+			session.GameStarted += HandleSessionStateChanged;		
+
+		}
+
+		void HandleSessionStateChanged (object sender, EventArgs e)
+		{
+            Game.Instance.Log("session state change");
+			SendSessionStateChange ();
+
+			if (session.SessionState == NetworkSessionState.Ended)
+				MGServerWorker.CancelAsync ();			
+		}
+
+		internal void ShutDown ()
+		{
+			MGServerWorker.CancelAsync ();			
+		}
+
+		private void MGServer_DoWork (object sender, DoWorkEventArgs e)
+		{
+			BackgroundWorker worker = sender as BackgroundWorker;
+
+			NetPeerConfiguration config = new NetPeerConfiguration (applicationIdentifier);
+			config.EnableMessageType (NetIncomingMessageType.DiscoveryRequest);
+			config.EnableMessageType (NetIncomingMessageType.DiscoveryResponse);
+			config.EnableMessageType (NetIncomingMessageType.NatIntroductionSuccess);
+
+			if (availableSession == null)
+				config.Port = port;
+
+			// create and start server
+			peer = new NetServer (config);
+			peer.Start ();
+
+			myLocalAddress = GetMyLocalIpAddress ();
+
+			IPAddress adr = IPAddress.Parse (myLocalAddress);
+			myLocalEndPoint = new IPEndPoint (adr, port);
+
+            // force a little wait until we have a LocalGamer otherwise things
+            // break. This is the first item in the queue so it shouldnt take long before we
+            // can continue.
+            while (session.LocalGamers.Count <= 0)
+            {
+                Thread.Sleep(10);
+            }
+
+			if (availableSession != null) {
+				if (!this.online) {
+					peer.Connect (availableSession.EndPoint);
+				} else {
+					RequestNATIntroduction (availableSession.EndPoint, peer);                    
+				}
+			} else {
+				if (this.online) {
+					IPAddress ipaddr = NetUtility.Resolve (masterServer);
+					if (ipaddr != null) {
+						m_masterServer = new IPEndPoint (ipaddr, masterserverport);
+						LocalNetworkGamer localMe = session.LocalGamers [0];
+
+						NetOutgoingMessage om = peer.CreateMessage ();
+
+						om.Write ((byte)0);
+						om.Write (session.AllGamers.Count);
+						om.Write (localMe.Gamertag);
+						om.Write (session.PrivateGamerSlots);
+						om.Write (session.MaxGamers);
+						om.Write (localMe.IsHost);
+						om.Write (myLocalEndPoint);
+						om.Write (peer.Configuration.AppIdentifier);
+						// send up session properties
+						int[] propertyData = new int[session.SessionProperties.Count * 2];
+						NetworkSessionProperties.WriteProperties (session.SessionProperties, propertyData);
+						for (int x = 0; x < propertyData.Length; x++) {
+							om.Write (propertyData [x]);
+						}
+						peer.SendUnconnectedMessage (om, m_masterServer); // send message to peer
+					} else {
+						throw new Exception ("Could not resolve live host");
+					}
+				}
+			}
+
+			// run until we are done
+			do {
+
+				NetIncomingMessage msg;
+				while ((msg = peer.ReadMessage ()) != null) {
+
+					switch (msg.MessageType) {
+					case NetIncomingMessageType.UnconnectedData :
+						break;
+					case NetIncomingMessageType.NatIntroductionSuccess:
+                        Game.Instance.Log("NAT punch through OK " + msg.SenderEndPoint);                            
+						peer.Connect (msg.SenderEndPoint);                            
+						break;
+					case NetIncomingMessageType.DiscoveryRequest:
+						//
+						// Server received a discovery request from a client; send a discovery response (with no extra data attached)
+						//
+						// Get the primary local gamer
+						LocalNetworkGamer localMe = session.LocalGamers [0];
+
+						NetOutgoingMessage om = peer.CreateMessage ();
+
+						om.Write (session.RemoteGamers.Count);
+						om.Write (localMe.Gamertag);
+						om.Write (session.PrivateGamerSlots);
+						om.Write (session.MaxGamers);
+						om.Write (localMe.IsHost);
+						int[] propertyData = new int[session.SessionProperties.Count * 2];
+						NetworkSessionProperties.WriteProperties (session.SessionProperties, propertyData);
+						for (int x = 0; x < propertyData.Length; x++) {
+							om.Write (propertyData [x]);
+						}
+
+						peer.SendDiscoveryResponse (om, msg.SenderEndPoint);
+						break;
+					case NetIncomingMessageType.VerboseDebugMessage:
+					case NetIncomingMessageType.DebugMessage:
+					case NetIncomingMessageType.WarningMessage:
+					case NetIncomingMessageType.ErrorMessage:
+						//
+						// Just print diagnostic messages to console
+						//
+                        Game.Instance.Log(msg.ReadString());
+						break;
+					case NetIncomingMessageType.StatusChanged:
+						NetConnectionStatus status = (NetConnectionStatus)msg.ReadByte ();
+						if (status == NetConnectionStatus.Disconnected) {
+                            Game.Instance.Log(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " disconnected! from " + msg.SenderEndPoint);
+							CommandGamerLeft cgj = new CommandGamerLeft (msg.SenderConnection.RemoteUniqueIdentifier);
+							CommandEvent cmde = new CommandEvent (cgj);
+							session.commandQueue.Enqueue (cmde);					
+						}
+						if (status == NetConnectionStatus.Connected) {
+							//
+							// A new player just connected!
+							//
+							if (!pendingGamers.ContainsKey (msg.SenderConnection.RemoteUniqueIdentifier)) {
+                                Game.Instance.Log(NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + " connected! from " + msg.SenderEndPoint);
+								pendingGamers.Add (msg.SenderConnection.RemoteUniqueIdentifier, msg.SenderConnection);
+								SendProfileRequest (msg.SenderConnection);
+							} else {
+                                Game.Instance.Log("Already have a connection for that user, this is probably due to both NAT intro requests working");
+							}
+						}
+
+						break;
+
+					case NetIncomingMessageType.Data:
+
+						NetworkMessageType mt = (NetworkMessageType)msg.ReadByte ();
+						switch (mt) {
+						case NetworkMessageType.Data:
+							byte[] data = new byte[msg.LengthBytes - 1];
+							msg.ReadBytes (data, 0, data.Length);
+							CommandEvent cme = new CommandEvent (new CommandReceiveData (msg.SenderConnection.RemoteUniqueIdentifier,
+												data));
+							session.commandQueue.Enqueue (cme);						
+							break;
+						case NetworkMessageType.Introduction:
+
+							var introductionAddress = msg.ReadString ();
+
+							try {
+								IPEndPoint endPoint = ParseIPEndPoint (introductionAddress);
+
+								if (myLocalEndPoint.ToString () != endPoint.ToString () && !AlreadyConnected (endPoint)) {
+
+                                    Game.Instance.Log("Received Introduction for: " + introductionAddress + 
+									" and I am: " + myLocalEndPoint + " from: " + msg.SenderEndPoint);
+									peer.Connect (endPoint);
+								}
+							} catch (Exception exc) {
+                                Game.Instance.Log("Error parsing Introduction: " + introductionAddress + " : " + exc.Message);
+							}
+
+							break;
+						case NetworkMessageType.GamerProfile:
+                            Game.Instance.Log("Profile recieved from: " + NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier));
+							if (pendingGamers.ContainsKey (msg.SenderConnection.RemoteUniqueIdentifier)) {
+								pendingGamers.Remove (msg.SenderConnection.RemoteUniqueIdentifier);
+								msg.ReadInt32 ();
+								string gamerTag = msg.ReadString ();
+								msg.ReadInt32 ();
+								msg.ReadInt32 ();
+								GamerStates state = (GamerStates)msg.ReadInt32 ();
+								state &= ~GamerStates.Local;
+								CommandGamerJoined cgj = new CommandGamerJoined (msg.SenderConnection.RemoteUniqueIdentifier);
+								cgj.GamerTag = gamerTag;
+								cgj.State = state;
+								CommandEvent cmde = new CommandEvent (cgj);
+								session.commandQueue.Enqueue (cmde);					
+							} else {
+                                Game.Instance.Log("We received a profile for an existing gamer.  Need to update it.");
+							}
+							break;
+						case NetworkMessageType.RequestGamerProfile:
+                            Game.Instance.Log("Profile Request recieved from: " + msg.SenderEndPoint);
+							SendProfile (msg.SenderConnection);
+							break;	
+						case NetworkMessageType.GamerStateChange:
+							GamerStates gamerstate = (GamerStates)msg.ReadInt32 ();
+							gamerstate &= ~GamerStates.Local;
+                            Game.Instance.Log("State Change from: " + msg.SenderEndPoint + " new State: " + gamerstate);
+							foreach (var gamer in session.RemoteGamers) {
+								if (gamer.RemoteUniqueIdentifier == msg.SenderConnection.RemoteUniqueIdentifier)
+									gamer.State = gamerstate;
+							}
+							break;								
+						case NetworkMessageType.SessionStateChange:
+							NetworkSessionState sessionState = (NetworkSessionState)msg.ReadInt32 ();
+
+							foreach (var gamer in session.RemoteGamers) {
+								if (gamer.RemoteUniqueIdentifier == msg.SenderConnection.RemoteUniqueIdentifier) {
+                                    Game.Instance.Log("Session State change from: " + NetUtility.ToHexString(msg.SenderConnection.RemoteUniqueIdentifier) + 
+										" session is now: " + sessionState);
+									if (gamer.IsHost && sessionState == NetworkSessionState.Playing) {
+										session.StartGame ();
+									}
+
+								}
+							}
+
+							break;								
+						}						
+						break;
+					}
+
+				}
+
+				// sleep to allow other processes to run smoothly
+				// This may need to be changed depending on network throughput
+				Thread.Sleep (1);
+
+				if (worker.CancellationPending) {
+                    Game.Instance.Log("worker CancellationPending");
+					e.Cancel = true;
+					done = true;
+				}
+			} while (!done);
+		}
+
+		private bool AlreadyConnected (IPEndPoint endPoint)
+		{
+			foreach (NetConnection player in peer.Connections) {
+				if (player.RemoteEndPoint == endPoint) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
+		private void MGServer_RunWorkerCompleted (object sender, RunWorkerCompletedEventArgs e)
+		{
+			if ((e.Cancelled == true)) {
+                Game.Instance.Log("Canceled");
+			} else if (!(e.Error == null)) {
+                Game.Instance.Log("Error: " + e.Error.Message);
+			}
+            Game.Instance.Log("worker Completed");
+
+			if (online && this.availableSession == null) {
+				// inform the master server we have closed
+				NetOutgoingMessage om = peer.CreateMessage ();
+
+				om.Write ((byte)3);
+				om.Write (this.session.Host.Gamertag);
+				om.Write (peer.Configuration.AppIdentifier);
+				peer.SendUnconnectedMessage (om, m_masterServer); // send message to peer
+			}
+			peer.Shutdown ("app exiting");
+		}	
+
+		internal void SendProfile (NetConnection player)
+		{
+			NetOutgoingMessage om = peer.CreateMessage ();
+			om.Write ((byte)NetworkMessageType.GamerProfile);
+			om.Write (session.AllGamers.Count);
+			om.Write (session.LocalGamers [0].Gamertag);
+			om.Write (session.PrivateGamerSlots);
+			om.Write (session.MaxGamers);
+			om.Write ((int)session.LocalGamers[0].State);
+            Game.Instance.Log("Sent profile to: " + NetUtility.ToHexString(player.RemoteUniqueIdentifier));
+			peer.SendMessage (om, player, NetDeliveryMethod.ReliableOrdered);			
+		}
+
+		internal void SendProfileRequest (NetConnection player)
+		{
+			NetOutgoingMessage om = peer.CreateMessage ();
+			om.Write ((byte)NetworkMessageType.RequestGamerProfile);
+            Game.Instance.Log("Sent profile request to: " + NetUtility.ToHexString(player.RemoteUniqueIdentifier));
+			peer.SendMessage (om, player, NetDeliveryMethod.ReliableOrdered);			
+		}
+
+		internal void SendPeerIntroductions (NetworkGamer gamer)
+		{
+
+			NetConnection playerConnection = null;
+
+			foreach (NetConnection player in peer.Connections) {
+				if (player.RemoteUniqueIdentifier == gamer.RemoteUniqueIdentifier) {
+					playerConnection = player;
+				}
+			}
+
+			if (playerConnection == null) {
+				return;
+			}
+
+			foreach (NetConnection player in peer.Connections) {
+                Game.Instance.Log("Introduction sent to: " + player.RemoteEndPoint);
+				NetOutgoingMessage om = peer.CreateMessage ();
+				om.Write ((byte)NetworkMessageType.Introduction);
+				om.Write (playerConnection.RemoteEndPoint.ToString ()); 
+
+				peer.SendMessage (om, player, NetDeliveryMethod.ReliableOrdered);
+			}
+		}
+
+		internal void SendGamerStateChange (NetworkGamer gamer)
+		{
+            Game.Instance.Log("SendGamerStateChange " + gamer.RemoteUniqueIdentifier);
+			NetOutgoingMessage om = peer.CreateMessage ();
+			om.Write ((byte)NetworkMessageType.GamerStateChange);
+			om.Write ((int)gamer.State);
+
+			SendMessage (om, SendDataOptions.Reliable, gamer);
+		}
+
+		internal void SendSessionStateChange ()
+		{
+            Game.Instance.Log("Send Session State Change");
+			NetOutgoingMessage om = peer.CreateMessage ();
+			om.Write ((byte)NetworkMessageType.SessionStateChange);
+			om.Write ((int)session.SessionState);
+
+			SendMessage (om, SendDataOptions.Reliable, null);
+		}		
+
+		public static IPEndPoint ParseIPEndPoint (string endPoint)
+		{
+			string[] ep = endPoint.Split (':');
+			if (ep.Length != 2)
+				throw new FormatException ("Invalid endpoint format");
+			IPAddress ip;
+			if (!IPAddress.TryParse (ep [0], out ip)) {
+				throw new FormatException ("Invalid ip-adress");
+			}
+			int port;
+			if (!int.TryParse (ep [1], out port)) {
+				throw new FormatException ("Invalid port");
+			}
+			return new IPEndPoint (ip, port);
+		}
+
+		internal static string GetMyLocalIpAddress ()
+		{
+			string localIP = "?";
+			IPHostEntry host;
+			
+			host = Dns.GetHostEntry (Dns.GetHostName ());
+			foreach (IPAddress ip in host.AddressList) {
+				// We only want those of type InterNetwork
+				if (ip.AddressFamily == AddressFamily.InterNetwork) {
+					// We will return the first one in the list
+					localIP = ip.ToString ();
+					break;
+				}
+			}
+			return localIP;
+		}
+
+
+        /// <summary>
+        /// Used to Simulate the delay between computers
+        /// </summary>
+        public TimeSpan SimulatedLatency
+        {
+            get
+            {                
+#if DEBUG
+		if (peer != null)
+                	return new TimeSpan(0,0,(int)peer.Configuration.SimulatedAverageLatency);
+		else
+			return new TimeSpan(0);
+#else
+                return new TimeSpan(0);
+#endif
+            }
+            set
+            {
+#if DEBUG
+		if (peer != null) {
+                	peer.Configuration.SimulatedMinimumLatency = (float)value.TotalSeconds;
+		}
+#endif
+            }
+        }
+
+
+        /// <summary>
+        /// Used to simulate the number of packets you might expect to loose.
+        /// </summary>
+        public float SimulatedPacketLoss
+        {
+            get
+            {
+#if DEBUG
+		if (peer != null)
+                	return peer.Configuration.SimulatedLoss;
+		else
+			return 0.0f;
+#else
+                return 0.0f;
+#endif
+            }
+            set
+            {
+#if DEBUG
+		if (peer != null) {
+                	peer.Configuration.SimulatedLoss = value;
+		}
+#endif
+            }
+        }		
+
+		internal void DiscoverPeers ()
+		{
+			peer.DiscoverLocalPeers (port);			    
+		}
+
+		internal void SendData (
+			byte[] data,
+			SendDataOptions options)
+		{
+			this.SendMessage (NetworkMessageType.Data, data, options, null);
+		}
+
+		internal void SendData (
+			byte[] data,
+			SendDataOptions options,
+			NetworkGamer gamer)
+		{
+			this.SendMessage (NetworkMessageType.Data, data, options, gamer);
+		}
+
+		private void SendMessage (NetworkMessageType messageType, byte[] data, SendDataOptions options, NetworkGamer gamer)
+		{
+
+			NetOutgoingMessage om = peer.CreateMessage ();
+
+			om.Write ((byte)messageType);
+			om.Write (data);
+
+			SendMessage (om, options, gamer);
+
+		}
+
+		private void SendMessage (NetOutgoingMessage om, SendDataOptions options, NetworkGamer gamer)
+		{
+			//Console.WriteLine("Data to send: " + data.Length);
+
+			//			foreach (NetConnection player in server.Connections) {
+			//				// ... send information about every other player (actually including self)
+			//				foreach (NetConnection otherPlayer in server.Connections) {
+
+			//					if (gamer != null && gamer.RemoteUniqueIdentifier != otherPlayer.RemoteUniqueIdentifier) {
+			//						continue;
+			//					}
+
+			NetDeliveryMethod ndm = NetDeliveryMethod.Unreliable;
+			switch (options) {
+			case SendDataOptions.Reliable:
+				ndm = NetDeliveryMethod.ReliableSequenced;
+				break;
+			case SendDataOptions.ReliableInOrder:
+				ndm = NetDeliveryMethod.ReliableOrdered;
+				break;
+			case SendDataOptions.InOrder:
+				ndm = NetDeliveryMethod.UnreliableSequenced;
+				break;
+			case SendDataOptions.None:
+				ndm = NetDeliveryMethod.Unknown;
+				break;
+			}
+			// send message
+			//server.SendToAll (om, player, ndm);
+			peer.SendToAll (om, ndm);
+
+			//				}
+			//			}				
+		}		
+
+		static NetPeer netPeer;
+		static List<NetIncomingMessage> discoveryMsgs;        
+
+		internal static void Find (NetworkSessionType sessionType)
+		{
+			NetPeerConfiguration config = new NetPeerConfiguration (applicationIdentifier);			
+			if (sessionType == NetworkSessionType.PlayerMatch) {
+				config.EnableMessageType (NetIncomingMessageType.UnconnectedData);
+				config.EnableMessageType (NetIncomingMessageType.NatIntroductionSuccess);
+			} else {
+				config.EnableMessageType (NetIncomingMessageType.DiscoveryRequest);
+			}
+            if (MonoGameNetworkConfiguration.Broadcast != IPAddress.None)
+            {
+                config.BroadcastAddress = MonoGameNetworkConfiguration.Broadcast;
+            }
+			netPeer = new NetPeer (config);
+			netPeer.Start ();
+
+			if (sessionType == NetworkSessionType.PlayerMatch) {
+				GetServerList (netPeer);
+			} else {
+				netPeer.DiscoverLocalPeers (port);
+			}
+
+			DateTime now = DateTime.UtcNow;
+
+			discoveryMsgs = new List<NetIncomingMessage> ();
+
+			do {
+				NetIncomingMessage msg;
+				while ((msg = netPeer.ReadMessage ()) != null) {
+					switch (msg.MessageType) {
+					case NetIncomingMessageType.DiscoveryResponse:
+						discoveryMsgs.Add (msg);
+						break;
+					case NetIncomingMessageType.UnconnectedData:
+						if (msg.SenderEndPoint.Equals (m_masterServer)) {
+							discoveryMsgs.Add (msg);
+							/*
+				* // it's from the master server - must be a host
+				IPEndPoint hostInternal = msg.ReadIPEndPoint();
+				IPEndPoint hostExternal = msg.ReadIPEndPoint();
+
+				m_hostList.Add(new IPEndPoint[] { hostInternal, hostExternal });                            
+				*/
+						}
+						break;
+					case NetIncomingMessageType.VerboseDebugMessage:
+					case NetIncomingMessageType.DebugMessage:
+					case NetIncomingMessageType.WarningMessage:
+					case NetIncomingMessageType.ErrorMessage:
+						//
+						// Just print diagnostic messages to console
+						//
+#if DEBUG
+						Console.WriteLine ("Find: " + msg.ReadString ());
+#endif
+						break;
+					}
+				}
+			} while ((DateTime.UtcNow - now).Seconds <= 2);
+
+			netPeer.Shutdown ("Find shutting down");
+		}
+
+		/// <summary>
+		/// Contacts the Master Server on the net and gets a list of available host games
+		/// </summary>
+		/// <param name="netPeer"></param>
+		private static void GetServerList (NetPeer netPeer)
+		{
+			m_masterServer = new IPEndPoint (NetUtility.Resolve (masterServer), masterserverport);
+
+			NetOutgoingMessage listRequest = netPeer.CreateMessage ();
+			listRequest.Write ((byte)1);
+			listRequest.Write (netPeer.Configuration.AppIdentifier);
+			netPeer.SendUnconnectedMessage (listRequest, m_masterServer);
+
+		}
+
+		public static void RequestNATIntroduction (IPEndPoint host, NetPeer peer)
+		{
+			if (host == null) {
+				return;
+			}
+
+			if (m_masterServer == null)
+				throw new Exception ("Must connect to master server first!");
+
+			NetOutgoingMessage om = peer.CreateMessage ();
+			om.Write ((byte)2); // NAT intro request
+
+			// write internal ipendpoint
+			IPAddress addr = IPAddress.Parse (GetMyLocalIpAddress ());
+			om.Write (new IPEndPoint (addr, peer.Port));
+
+			// write external address of host to request introduction to
+			IPEndPoint hostEp = new IPEndPoint (host.Address, port);
+			om.Write (hostEp);
+			om.Write (peer.Configuration.AppIdentifier); // send the app id
+
+			peer.SendUnconnectedMessage (om, m_masterServer);
+		}
+
+		internal static void FindResults (List<AvailableNetworkSession> networkSessions)
+		{
+
+			foreach (NetIncomingMessage im in discoveryMsgs) {
+
+				AvailableNetworkSession available = new AvailableNetworkSession ();
+				switch (im.MessageType) {
+				case NetIncomingMessageType.DiscoveryResponse :                        
+					int currentGameCount = im.ReadInt32 ();
+					string gamerTag = im.ReadString ();
+					int openPrivateGamerSlots = im.ReadInt32 ();
+					int openPublicGamerSlots = im.ReadInt32 ();
+					im.ReadBoolean (); //isHost
+
+					NetworkSessionProperties properties = new NetworkSessionProperties ();
+					int[] propertyData = new int[properties.Count * 2];
+					for (int x = 0; x < propertyData.Length; x++) {
+						propertyData [x] = im.ReadInt32 ();
+					}
+
+					NetworkSessionProperties.ReadProperties (properties, propertyData);
+					available.SessionProperties = properties;
+
+					available.SessionType = NetworkSessionType.SystemLink;
+					available.CurrentGamerCount = currentGameCount;
+					available.HostGamertag = gamerTag;
+					available.OpenPrivateGamerSlots = openPrivateGamerSlots;
+					available.OpenPublicGamerSlots = openPublicGamerSlots;
+					available.EndPoint = im.SenderEndPoint;
+					available.InternalEndpont = null;
+					break;
+				case NetIncomingMessageType.UnconnectedData :
+					if (im.SenderEndPoint.Equals (m_masterServer)) {
+						currentGameCount = im.ReadInt32 ();
+						gamerTag = im.ReadString ();
+						openPrivateGamerSlots = im.ReadInt32 ();
+						openPublicGamerSlots = im.ReadInt32 ();
+						im.ReadBoolean (); // isHost
+						IPEndPoint hostInternal = im.ReadIPEndPoint ();
+						IPEndPoint hostExternal = im.ReadIPEndPoint ();
+						available.SessionType = NetworkSessionType.PlayerMatch;
+						available.CurrentGamerCount = currentGameCount;
+						available.HostGamertag = gamerTag;
+						available.OpenPrivateGamerSlots = openPrivateGamerSlots;
+						available.OpenPublicGamerSlots = openPublicGamerSlots;
+						// its data from the master server so it includes the internal and external endponts
+						available.EndPoint = hostExternal;
+						available.InternalEndpont = hostInternal;
+					}
+					break;
+				}
+
+
+				networkSessions.Add (available);
+
+			}
+		}
+
+		internal void UpdateLiveSession (NetworkSession networkSession)
+		{
+			if (peer != null && m_masterServer != null && networkSession.IsHost) {
+				NetOutgoingMessage om = peer.CreateMessage ();
+
+				om.Write ((byte)0);
+				om.Write (session.AllGamers.Count);
+				om.Write (session.LocalGamers [0].Gamertag);
+				om.Write (session.PrivateGamerSlots);
+				om.Write (session.MaxGamers);
+				om.Write (session.LocalGamers [0].IsHost);
+				IPAddress adr = IPAddress.Parse (GetMyLocalIpAddress ());
+				om.Write (new IPEndPoint (adr, port));
+				om.Write (peer.Configuration.AppIdentifier);
+				peer.SendUnconnectedMessage (om, m_masterServer); // send message to peer
+			}
+		}
+
+        internal bool IsReady { get { return this.peer != null; } }
+	}
+}
diff --git a/MonoGame.Framework/Net/NetworkException.cs b/MonoGame.Framework/Net/NetworkException.cs
new file mode 100644
index 00000000000..025bdb95ebb
--- /dev/null
+++ b/MonoGame.Framework/Net/NetworkException.cs
@@ -0,0 +1,69 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+using System;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.Net
+{
+
+#if WINDOWS_UAP
+    [DataContract]
+#else
+    [Serializable]
+#endif
+	public class NetworkException : Exception
+	{
+
+		public NetworkException ()
+		{
+		}
+		
+		public NetworkException( string message )
+		{
+			
+		}
+		
+		public NetworkException (string message, Exception innerException)
+		{
+			
+		}
+	}
+}
diff --git a/MonoGame.Framework/Net/NetworkGamer.cs b/MonoGame.Framework/Net/NetworkGamer.cs
new file mode 100644
index 00000000000..b1605808e99
--- /dev/null
+++ b/MonoGame.Framework/Net/NetworkGamer.cs
@@ -0,0 +1,233 @@
+// #region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+// #endregion License
+// 
+
+#region Using clause
+using System;
+using System.ComponentModel;
+
+using Microsoft.Xna.Framework.GamerServices;
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+	public class NetworkGamer : Gamer, INotifyPropertyChanged
+	{
+		
+		private byte id;
+		NetworkSession session; 
+		//bool isHost;
+		//bool isLocal;
+		//bool hasVoice;
+		long remoteUniqueIdentifier = -1;
+		GamerStates gamerState;
+		GamerStates oldGamerState;
+		
+		// Declare the event
+		public event PropertyChangedEventHandler PropertyChanged;
+		
+		
+		public NetworkGamer ( NetworkSession session, byte id, GamerStates state)
+		{
+			this.id = id;
+			this.session = session;
+			this.gamerState = state;
+			// We will modify these HasFlags to inline code because MonoTouch does not support
+			// the HasFlag method.  Also after reading this : http://msdn.microsoft.com/en-us/library/system.enum.hasflag.aspx#2
+			// it just might be better to inline it anyway.
+			//this.isHost = (state & GamerStates.Host) != 0; // state.HasFlag(GamerStates.Host);
+			//this.isLocal = (state & GamerStates.Local) != 0; // state.HasFlag(GamerStates.Local);
+			//this.hasVoice = (state & GamerStates.HasVoice) != 0; //state.HasFlag(GamerStates.HasVoice);
+			
+			// *** NOTE TODO **
+			// This whole state stuff need to be looked at again.  Maybe we should not be using local
+			//  variables here and instead just use the flags within the gamerState.
+			
+			this.gamerState = state;
+			this.oldGamerState = state;
+		}
+		
+		internal long RemoteUniqueIdentifier
+		{
+			get { return remoteUniqueIdentifier; }
+			set { remoteUniqueIdentifier = value; }
+		}
+		
+		public bool HasLeftSession 
+		{ 
+			get
+			{
+				return false;
+			}
+		}
+		
+		public bool HasVoice 
+		{ 
+			get
+			{
+				return (gamerState & GamerStates.HasVoice) != 0;
+			}
+		}
+		
+		public byte Id 
+		{ 
+			get
+			{
+				return id;
+			}
+		}
+		
+		public bool IsGuest 
+		{ 
+			get
+			{
+				return (gamerState & GamerStates.Guest) != 0;
+			}
+		}
+		
+		public bool IsHost 
+		{ 
+			get
+			{
+				return (gamerState & GamerStates.Host) != 0;
+			}
+		}
+		
+		public bool IsLocal 
+		{ 
+			get
+			{
+				return (gamerState & GamerStates.Local) != 0;
+			}
+		}
+		
+		public bool IsMutedByLocalUser 
+		{ 
+			get
+			{
+				return true;
+			}
+		}
+		
+		public bool IsPrivateSlot 
+		{ 
+			get
+			{
+				return false;
+			}
+		}
+		
+		public bool IsReady 
+		{ 
+			get
+			{
+				return (gamerState & GamerStates.Ready) != 0;
+			}
+			set
+			{
+				if (((gamerState & GamerStates.Ready) != 0) != value) {
+					if (value)
+						gamerState |= GamerStates.Ready;
+					else
+						gamerState &= ~GamerStates.Ready;
+					OnPropertyChanged("Ready");
+				}
+			}
+		}
+		
+		public bool IsTalking 
+		{ 
+			get
+			{
+				return false;
+			}
+		}
+		
+		private NetworkMachine _Machine;
+		public NetworkMachine Machine 
+		{ 
+			get
+			{
+				return _Machine;
+			}
+			set
+			{
+				if (_Machine != value )
+					_Machine = value;
+			}
+		}
+		
+		public TimeSpan RoundtripTime 
+		{ 
+			get
+			{
+				return TimeSpan.MinValue;
+			}
+		}
+		
+		public NetworkSession Session 
+		{ 
+			get
+			{
+				return session;
+			}
+		} 
+		
+		internal GamerStates State {
+			get { return gamerState; }
+			set { gamerState = value; }
+		}
+		
+		internal GamerStates OldState {
+			get { return oldGamerState; }
+		}		
+		
+		// Create the OnPropertyChanged method to raise the event
+		protected void OnPropertyChanged(string name)
+		{
+			PropertyChangedEventHandler handler = PropertyChanged;
+			if (handler != null)
+			{
+				handler(this, new PropertyChangedEventArgs(name));
+			}
+		}
+		
+	}
+}
diff --git a/MonoGame.Framework/Net/NetworkMachine.cs b/MonoGame.Framework/Net/NetworkMachine.cs
new file mode 100644
index 00000000000..29db6fc93fe
--- /dev/null
+++ b/MonoGame.Framework/Net/NetworkMachine.cs
@@ -0,0 +1,84 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+#region Using clause
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+using Microsoft.Xna.Framework.GamerServices;
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+	// Represents a physical machine that is participating in a multiplayer session. 
+	// It can be used to detect when more than one NetworkGamer is playing on the same actual machine. 	
+	public sealed class NetworkMachine
+	{
+		private GamerCollection<NetworkGamer> gamers;
+		
+		#region Constructors
+		public NetworkMachine ()
+		{
+			gamers = new GamerCollection<NetworkGamer>();
+		}
+		#endregion
+		
+		#region Methods
+        /*
+		public void RemoveFromSession ()
+		{
+			throw new NotImplementedException();
+		}
+        */
+		#endregion
+		
+		#region Methods
+		public GamerCollection<NetworkGamer> Gamers 
+		{ 
+			get
+			{
+				return gamers;
+			}
+		}
+		#endregion
+	}
+}
diff --git a/MonoGame.Framework/Net/NetworkMessageType.cs b/MonoGame.Framework/Net/NetworkMessageType.cs
new file mode 100644
index 00000000000..f63bf585281
--- /dev/null
+++ b/MonoGame.Framework/Net/NetworkMessageType.cs
@@ -0,0 +1,18 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Net
+{
+	// These are for internal use specifying the Data Packet Contents
+	internal enum NetworkMessageType : byte
+	{
+		Data = 0,
+		GamerJoined = 1,
+		GamerLeft = 2,
+		Introduction = 3,
+		GamerProfile = 4,
+		RequestGamerProfile = 5,
+		GamerStateChange = 6,
+		SessionStateChange = 7,
+	}
+}
+
diff --git a/MonoGame.Framework/Net/NetworkNotAvailableException.cs b/MonoGame.Framework/Net/NetworkNotAvailableException.cs
new file mode 100644
index 00000000000..2dce9f9b09d
--- /dev/null
+++ b/MonoGame.Framework/Net/NetworkNotAvailableException.cs
@@ -0,0 +1,68 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+using System;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.Net
+{
+#if WINDOWS_UAP
+    [DataContract]
+#else
+    [Serializable]
+#endif
+    public class NetworkNotAvailableException : NetworkException
+	{
+		public NetworkNotAvailableException()
+		{
+			
+		}
+		
+		public NetworkNotAvailableException( string message ) : base(message)
+		{
+			
+		}
+		
+		public NetworkNotAvailableException (string message, Exception innerException) : base(message, innerException)
+		{
+			
+		}
+	}
+}
diff --git a/MonoGame.Framework/Net/NetworkSession.cs b/MonoGame.Framework/Net/NetworkSession.cs
new file mode 100644
index 00000000000..68fd8c48497
--- /dev/null
+++ b/MonoGame.Framework/Net/NetworkSession.cs
@@ -0,0 +1,1188 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+#region Using clause
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.Remoting.Messaging;
+using System.Threading;
+
+using Microsoft.Xna.Framework.GamerServices;
+
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+	// The delegate must have the same signature as the method
+	// it will call asynchronously.
+	public delegate NetworkSession NetworkSessionAsynchronousCreate (
+		NetworkSessionType sessionType,// Type of session being hosted.
+		int maxLocalGamers,// Maximum number of local players on the same gaming machine in this network session.
+		int maxGamers,		// Maximum number of players allowed in this network session.  For Zune-based games, this value must be between 2 and 8; 8 is the maximum number of players supported in the session.
+		int privateGamerSlots, // Number of reserved private session slots created for the session. This value must be less than maximumGamers. 
+		NetworkSessionProperties sessionProperties, // Properties of the session being created.
+		int hostGamer,		// Gamer Index of the host
+		bool isHost	// If the session is for host or not 
+	);
+
+	public delegate AvailableNetworkSessionCollection  NetworkSessionAsynchronousFind (
+			NetworkSessionType sessionType,
+			int hostGamer,
+			int maxLocalGamers,
+			NetworkSessionProperties searchProperties);
+
+	public delegate NetworkSession NetworkSessionAsynchronousJoin (AvailableNetworkSession availableSession);
+
+	public delegate NetworkSession NetworkSessionAsynchronousJoinInvited (int maxLocalGamers);
+
+	public sealed class NetworkSession : IDisposable
+	{
+		internal static List<NetworkSession> activeSessions = new List<NetworkSession>();
+		
+		private NetworkSessionState sessionState;
+		//private static NetworkSessionType networkSessionType;	
+		private GamerCollection<NetworkGamer> _allGamers;
+		private GamerCollection<LocalNetworkGamer> _localGamers;
+		private GamerCollection<NetworkGamer> _remoteGamers;
+		private GamerCollection<NetworkGamer> _previousGamers;
+		
+		internal Queue<CommandEvent> commandQueue;
+
+		// use the static Create or BeginCreate methods
+		private NetworkSession ()
+		{
+			activeSessions.Add(this);
+		}
+		
+        ~NetworkSession()
+        {
+            Dispose(false);
+        }
+
+		private NetworkSessionType sessionType;
+		private int maxGamers;
+		private int privateGamerSlots;
+		private NetworkSessionProperties sessionProperties;
+		private bool isHost = false;
+		private NetworkGamer hostingGamer;
+
+		internal MonoGamerPeer networkPeer;
+		
+		private NetworkSession (NetworkSessionType sessionType, int maxGamers, int privateGamerSlots, NetworkSessionProperties sessionProperties, bool isHost, int hostGamer)
+			: this(sessionType, maxGamers, privateGamerSlots, sessionProperties, isHost, hostGamer, null)
+		{
+		}
+		
+		private NetworkSession (NetworkSessionType sessionType, int maxGamers, int privateGamerSlots, NetworkSessionProperties sessionProperties, bool isHost, int hostGamer, AvailableNetworkSession availableSession) : this()
+		{
+			if (sessionProperties == null) {
+				throw new ArgumentNullException ("sessionProperties");
+			}
+			
+			_allGamers = new GamerCollection<NetworkGamer>();
+			_localGamers = new GamerCollection<LocalNetworkGamer>();
+//			for (int x = 0; x < Gamer.SignedInGamers.Count; x++) {
+//				GamerStates states = GamerStates.Local;
+//				if (x == 0)
+//					states |= GamerStates.Host;
+//				LocalNetworkGamer localGamer = new LocalNetworkGamer(this, (byte)x, states);
+//				localGamer.SignedInGamer = Gamer.SignedInGamers[x];
+//				_allGamers.AddGamer(localGamer);
+//				_localGamers.AddGamer(localGamer);
+//				
+//				// We will attach a property change handler to local gamers
+//				//  se that we can broadcast the change to other peers.
+//				localGamer.PropertyChanged += HandleGamerPropertyChanged;	
+//				
+//			}
+
+			_remoteGamers = new GamerCollection<NetworkGamer>();
+			_previousGamers = new GamerCollection<NetworkGamer>();
+			hostingGamer = null;
+			
+			commandQueue = new Queue<CommandEvent>();			
+			
+			this.sessionType = sessionType;
+			this.maxGamers = maxGamers;
+			this.privateGamerSlots = privateGamerSlots;
+			this.sessionProperties = sessionProperties;
+			this.isHost = isHost;
+            if (isHost)
+                networkPeer = new MonoGamerPeer(this, null);
+            else
+            {
+                if (networkPeer == null)
+                    networkPeer = new MonoGamerPeer(this, availableSession);
+            }
+            			
+			CommandGamerJoined gj = new CommandGamerJoined(hostGamer, this.isHost, true);
+			commandQueue.Enqueue(new CommandEvent(gj));
+		}
+		
+		public static NetworkSession Create (
+			NetworkSessionType sessionType,// Type of session being hosted.
+			IEnumerable<SignedInGamer> localGamers, // Maximum number of local players on the same gaming machine in this network session.
+			int maxGamers, // Maximum number of players allowed in this network session.  For Zune-based games, this value must be between 2 and 8; 8 is the maximum number of players supported in the session.
+			int privateGamerSlots, // Number of reserved private session slots created for the session. This value must be less than maximumGamers. 
+			NetworkSessionProperties sessionProperties // Properties of the session being created.
+			)
+		{
+			try {
+				return EndCreate(BeginCreate(sessionType, localGamers, maxGamers,privateGamerSlots, sessionProperties,null, null));
+			} finally {
+				
+			}
+			
+		} 
+		
+		public static NetworkSession Create (
+			NetworkSessionType sessionType,	// Type of session being hosted.
+			int maxLocalGamers,		// Maximum number of local players on the same gaming machine in this network session.
+			int maxGamers			// Maximum number of players allowed in this network session.  For Zune-based games, this value must be between 2 and 8; 8 is the maximum number of players supported in the session.
+		)
+		{
+			try {
+				return EndCreate(BeginCreate(sessionType,maxLocalGamers,maxGamers,null, null));
+			} finally {
+				
+			}
+			
+		}
+
+		public static NetworkSession Create (
+			NetworkSessionType sessionType,
+			int maxLocalGamers,
+			int maxGamers,
+			int privateGamerSlots,
+			NetworkSessionProperties sessionProperties)
+		{
+			try {
+				return EndCreate(BeginCreate(sessionType,maxLocalGamers,maxGamers,privateGamerSlots,sessionProperties,null, null));
+			} finally {
+				
+			}
+			
+		}
+		
+		private static NetworkSession Create (
+			NetworkSessionType sessionType,
+			int maxLocalGamers,
+			int maxGamers,
+			int privateGamerSlots,
+			NetworkSessionProperties sessionProperties,
+			int hostGamer,
+			bool isHost)
+		{
+			
+			NetworkSession session = null;
+			
+			try {
+				if (sessionProperties == null)
+					sessionProperties = new NetworkSessionProperties();
+				session = new NetworkSession (sessionType, maxGamers, privateGamerSlots, sessionProperties, isHost, hostGamer);
+				
+			} finally {
+			}
+			
+			return session;
+		}
+		
+		#region IDisposable Members
+
+		public void Dispose ()
+		{
+			this.Dispose(true);
+			GC.SuppressFinalize(this);				
+		}
+		
+		public void Dispose (bool disposing) 
+		{
+            if (!_isDisposed)
+            {
+                if (disposing)
+                {
+                    foreach (Gamer gamer in _allGamers)
+                    {
+                        gamer.Dispose();
+                    }
+
+                    // Make sure we shut down our server instance as we no longer need it.
+                    if (networkPeer != null)
+                    {
+                        networkPeer.ShutDown();
+                    }
+                    if (networkPeer != null)
+                    {
+                        networkPeer.ShutDown();
+                    }
+                }
+
+                this._isDisposed = true;
+            }
+		}
+
+	#endregion
+
+		public void AddLocalGamer (SignedInGamer gamer)
+		{
+			if (gamer == null)
+				throw new ArgumentNullException ("gamer");
+			
+//			_allGamers.AddGamer(gamer);
+//			_localGamers.AddGamer((LocalNetworkGamer)gamer);
+//			
+//			// We will attach a property change handler to local gamers
+//			//  se that we can broadcast the change to other peers.
+//			gamer.PropertyChanged += HandleGamerPropertyChanged;	
+		}
+
+		public static IAsyncResult BeginCreate (NetworkSessionType sessionType,
+			IEnumerable<SignedInGamer> localGamers,
+			int maxGamers,
+			int privateGamerSlots,
+			NetworkSessionProperties sessionProperties,
+			AsyncCallback callback,
+			Object asyncState)
+		{
+			int hostGamer = -1;
+			hostGamer = GetHostingGamerIndex (localGamers);            
+			return BeginCreate (sessionType, hostGamer, 4, maxGamers, privateGamerSlots, sessionProperties, callback, asyncState);
+		}
+
+		public static IAsyncResult BeginCreate (
+			NetworkSessionType sessionType,
+			int maxLocalGamers,
+			int maxGamers,
+			AsyncCallback callback,
+			Object asyncState)
+		{
+			return BeginCreate (sessionType, -1, maxLocalGamers, maxGamers, 0, null, callback, asyncState);
+		}
+
+		public static IAsyncResult BeginCreate (
+			NetworkSessionType sessionType,
+			int maxLocalGamers,
+			int maxGamers,
+			int privateGamerSlots,
+			NetworkSessionProperties sessionProperties,
+			AsyncCallback callback,
+			Object asyncState)
+		{
+			return BeginCreate (sessionType, -1, maxLocalGamers, maxGamers, privateGamerSlots, sessionProperties, callback, asyncState);
+		}
+
+		private static IAsyncResult BeginCreate (NetworkSessionType sessionType,
+			int hostGamer,
+			int maxLocalGamers,
+			int maxGamers,
+			int privateGamerSlots,
+			NetworkSessionProperties sessionProperties,
+			AsyncCallback callback,
+			Object asyncState)
+		{
+			if (maxLocalGamers < 1 || maxLocalGamers > 4) 
+				throw new ArgumentOutOfRangeException ( "Maximum local players must be between 1 and 4." );
+			if (maxGamers < 2 || maxGamers > 32) 
+				throw new ArgumentOutOfRangeException ( "Maximum number of gamers must be between 2 and 32." );
+			try {
+				NetworkSessionAsynchronousCreate AsynchronousCreate = new NetworkSessionAsynchronousCreate (Create);
+				return AsynchronousCreate.BeginInvoke (sessionType, maxLocalGamers, maxGamers, privateGamerSlots, sessionProperties, hostGamer, true, callback, asyncState);
+			} finally {
+			}		
+			
+		}
+
+		internal static int GetHostingGamerIndex (IEnumerable<SignedInGamer> localGamers)
+		{
+			SignedInGamer hostGamer = null;
+
+			if (localGamers == null) {
+				throw new ArgumentNullException ("localGamers");
+			}
+			foreach (SignedInGamer gamer in localGamers) {
+				if (gamer == null) {
+					throw new ArgumentException ("gamer can not be null in list of localGamers.");
+				}
+				if (gamer.IsDisposed) {
+					throw new ObjectDisposedException ("localGamers", "A gamer is disposed in the list of localGamers");
+				}
+				if (hostGamer == null) {
+					hostGamer = gamer;
+				}
+			}
+			if (hostGamer == null) {
+				throw new ArgumentException ("Invalid gamer in localGamers.");
+			}
+
+			return (int)hostGamer.PlayerIndex;
+		}		
+
+		public static IAsyncResult BeginFind (
+			NetworkSessionType sessionType,
+			IEnumerable<SignedInGamer> localGamers,
+			NetworkSessionProperties searchProperties,
+			AsyncCallback callback,
+			Object asyncState)
+		{
+			int hostGamer = -1;
+			hostGamer = GetHostingGamerIndex (localGamers);
+
+			return BeginFind (sessionType, hostGamer, 4, searchProperties, callback, asyncState);
+
+
+		}
+
+		public static IAsyncResult BeginFind (
+			NetworkSessionType sessionType,
+			int maxLocalGamers,
+			NetworkSessionProperties searchProperties,
+			AsyncCallback callback,
+			Object asyncState)
+		{
+			return BeginFind (sessionType, -1, 4, searchProperties, callback, asyncState);
+		}
+		
+		private static IAsyncResult BeginFind (
+			NetworkSessionType sessionType,
+			int hostGamer,
+			int maxLocalGamers,
+			NetworkSessionProperties searchProperties,
+			AsyncCallback callback,
+			Object asyncState)
+		{
+			if (sessionType == NetworkSessionType.Local)
+				throw new ArgumentException ( "NetworkSessionType cannot be NetworkSessionType.Local" );
+			if (maxLocalGamers < 1 || maxLocalGamers > 4)
+				throw new ArgumentOutOfRangeException ( "maxLocalGamers must be between 1 and 4." );
+
+			try {
+				NetworkSessionAsynchronousFind AsynchronousFind = new NetworkSessionAsynchronousFind (Find);
+				return AsynchronousFind.BeginInvoke (sessionType, hostGamer, maxLocalGamers, searchProperties, callback, asyncState);
+			} finally {
+			}
+		}
+
+		public static IAsyncResult BeginJoin (
+			AvailableNetworkSession availableSession,
+			AsyncCallback callback,
+			Object asyncState)
+		{
+			if (availableSession == null)
+				throw new ArgumentNullException ();			
+
+			try {
+				NetworkSessionAsynchronousJoin AsynchronousJoin = new NetworkSessionAsynchronousJoin (JoinSession);
+				return AsynchronousJoin.BeginInvoke (availableSession, callback, asyncState);
+			} finally {
+			}
+		}
+
+        /*
+		public static IAsyncResult BeginJoinInvited (
+			IEnumerable<SignedInGamer> localGamers,
+			AsyncCallback callback,
+			Object asyncState)
+		{	
+			try {
+				throw new NotImplementedException ();
+			} finally {
+			}
+		}
+
+		public static IAsyncResult BeginJoinInvited (
+			int maxLocalGamers,
+			AsyncCallback callback,
+			Object asyncState)
+		{
+			if (maxLocalGamers < 1 || maxLocalGamers > 4)
+				throw new ArgumentOutOfRangeException ( "maxLocalGamers must be between 1 and 4." );
+
+			try {
+				NetworkSessionAsynchronousJoinInvited AsynchronousJoinInvited = new NetworkSessionAsynchronousJoinInvited (JoinInvited);
+				return AsynchronousJoinInvited.BeginInvoke (maxLocalGamers, callback, asyncState);
+			} finally {
+			}
+		}
+        */
+
+        public static NetworkSession EndCreate (IAsyncResult result)
+		{
+			NetworkSession returnValue = null;
+			try {
+				// Retrieve the delegate.
+				AsyncResult asyncResult = (AsyncResult)result;
+
+				// Wait for the WaitHandle to become signaled.
+				result.AsyncWaitHandle.WaitOne ();
+
+
+				// Call EndInvoke to retrieve the results.
+				if (asyncResult.AsyncDelegate is NetworkSessionAsynchronousCreate) {
+					returnValue = ((NetworkSessionAsynchronousCreate)asyncResult.AsyncDelegate).EndInvoke (result);
+				}	
+			} finally {
+				// Close the wait handle.
+				result.AsyncWaitHandle.Close ();	 
+			}
+			
+			return returnValue;
+		}
+
+		public static AvailableNetworkSessionCollection EndFind (IAsyncResult result)
+		{
+			AvailableNetworkSessionCollection returnValue = null;
+			List<AvailableNetworkSession> networkSessions = new List<AvailableNetworkSession>();
+			
+			try {
+				// Retrieve the delegate.
+                AsyncResult asyncResult = (AsyncResult)result;            	
+
+      
+				// Wait for the WaitHandle to become signaled.
+				result.AsyncWaitHandle.WaitOne ();
+				               
+				
+				// Call EndInvoke to retrieve the results.
+				if (asyncResult.AsyncDelegate is NetworkSessionAsynchronousFind) {
+					returnValue = ((NetworkSessionAsynchronousFind)asyncResult.AsyncDelegate).EndInvoke (result);                    
+				
+					MonoGamerPeer.FindResults(networkSessions);
+                }
+
+            } finally {
+				// Close the wait handle.
+				result.AsyncWaitHandle.Close ();
+			}
+			returnValue = new AvailableNetworkSessionCollection(networkSessions);
+			return returnValue;
+		}
+
+		public void EndGame ()
+		{
+			try {
+				CommandSessionStateChange ssc = new CommandSessionStateChange(NetworkSessionState.Lobby, sessionState);
+				commandQueue.Enqueue(new CommandEvent(ssc));
+
+			} finally {
+			}
+		}
+
+		public static NetworkSession EndJoin (IAsyncResult result)
+		{
+			NetworkSession returnValue = null;
+			try {
+				// Retrieve the delegate.
+				AsyncResult asyncResult = (AsyncResult)result;            	
+
+				// Wait for the WaitHandle to become signaled.
+				result.AsyncWaitHandle.WaitOne ();
+
+				// Call EndInvoke to retrieve the results.
+				if (asyncResult.AsyncDelegate is NetworkSessionAsynchronousJoin) {
+					returnValue = ((NetworkSessionAsynchronousJoin)asyncResult.AsyncDelegate).EndInvoke (result);
+				}		            	            
+			} finally {
+				// Close the wait handle.
+				result.AsyncWaitHandle.Close ();
+			}
+			return returnValue;
+		}
+
+        /*
+		public static NetworkSession EndJoinInvited (IAsyncResult result)
+		{
+			NetworkSession returnValue = null;
+			try {
+				// Retrieve the delegate.
+				AsyncResult asyncResult = (AsyncResult)result;            	
+
+				// Wait for the WaitHandle to become signaled.
+				result.AsyncWaitHandle.WaitOne ();
+
+				// Call EndInvoke to retrieve the results.
+				if (asyncResult.AsyncDelegate is NetworkSessionAsynchronousJoinInvited) {
+					returnValue = ((NetworkSessionAsynchronousJoinInvited)asyncResult.AsyncDelegate).EndInvoke (result);
+				}		            	            
+			} finally {
+				// Close the wait handle.
+				result.AsyncWaitHandle.Close ();
+			}
+			return returnValue;
+		}
+        */
+
+		public static AvailableNetworkSessionCollection Find (
+			NetworkSessionType sessionType,
+			IEnumerable<SignedInGamer> localGamers,
+			NetworkSessionProperties searchProperties)
+		{
+			int hostGamer = -1;
+			hostGamer = GetHostingGamerIndex(localGamers);
+			return EndFind(BeginFind(sessionType, hostGamer, 4, searchProperties,null,null));
+		}
+
+		public static AvailableNetworkSessionCollection Find (
+			NetworkSessionType sessionType,
+			int maxLocalGamers,
+			NetworkSessionProperties searchProperties)
+		{
+			return EndFind(BeginFind(sessionType, -1, maxLocalGamers, searchProperties,null,null));
+		}
+
+		private static AvailableNetworkSessionCollection Find (
+			NetworkSessionType sessionType,
+			int hostGamer,
+			int maxLocalGamers,
+			NetworkSessionProperties searchProperties)
+		{
+			try {
+				if (maxLocalGamers < 1 || maxLocalGamers > 4)
+					throw new ArgumentOutOfRangeException ( "maxLocalGamers must be between 1 and 4." );
+
+				List<AvailableNetworkSession> availableNetworkSessions = new List<AvailableNetworkSession> ();
+				MonoGamerPeer.Find(sessionType);
+				return new AvailableNetworkSessionCollection ( availableNetworkSessions );
+			} finally {
+			}
+		}
+		
+		public NetworkGamer FindGamerById (byte gamerId)
+		{
+			try {
+				foreach (NetworkGamer gamer in _allGamers) {
+					if (gamer.Id == gamerId)
+						return gamer;
+				}
+				
+				return null;
+			} finally {
+			}
+		}
+
+		public static NetworkSession Join (AvailableNetworkSession availableSession)
+		{
+			return EndJoin(BeginJoin(availableSession, null, null));
+		}
+		
+		private static NetworkSession JoinSession (AvailableNetworkSession availableSession) 
+		{
+			NetworkSession session = null;
+			
+			try {                
+				NetworkSessionType sessionType = availableSession.SessionType;
+				int maxGamers = 32;
+				int privateGamerSlots = 0;
+				bool isHost = false;
+				int hostGamer = -1;
+				NetworkSessionProperties sessionProperties = availableSession.SessionProperties;
+				if (sessionProperties == null)
+					sessionProperties = new NetworkSessionProperties();
+				session = new NetworkSession (sessionType, maxGamers, privateGamerSlots, sessionProperties, isHost, hostGamer, availableSession);
+				
+			} finally {
+			}
+			
+			return session;		
+		}
+		
+        /*
+		public static NetworkSession JoinInvited (IEnumerable<SignedInGamer> localGamers)
+		{
+			try {
+				throw new NotImplementedException ();
+			} finally {
+			}
+		}
+        
+		public static NetworkSession JoinInvited (int maxLocalGamers)
+		{
+			if (maxLocalGamers < 1 || maxLocalGamers > 4)
+				throw new ArgumentOutOfRangeException ( "maxLocalGamers must be between 1 and 4." );
+
+			try {
+				throw new NotImplementedException ();
+			} finally {
+			}
+		}
+		*/
+
+		// I am not really sure how this is suppose to work so am just fleshing it in
+		//  for the way I think it should.  This will also send a message to all connected
+		//  peers for a state change.
+		public void ResetReady ()
+		{
+			foreach (NetworkGamer gamer in _localGamers) {
+				gamer.IsReady = false;
+			}
+		}
+
+		public void StartGame ()
+		{
+			try {
+				CommandSessionStateChange ssc = new CommandSessionStateChange(NetworkSessionState.Playing, sessionState);
+				commandQueue.Enqueue(new CommandEvent(ssc));
+				//sessionState = NetworkSessionState.Playing;
+			} finally {
+			}
+		}
+
+		public void Update ()
+		{
+			// Updates the state of the multiplayer session. 
+			try {
+				while (commandQueue.Count > 0 && networkPeer.IsReady) {
+					var command = (CommandEvent)commandQueue.Dequeue();
+					
+					// for some screwed up reason we are dequeueing something
+					// that is null so we will just continue.  I am not sure
+					// if is jumbled data coming in from the connection or
+					// something that is not being done correctly in code
+					//  For sure this needs to be looked at although it is not
+					//  causing any real problems right now.
+					if (command == null) {
+						continue;
+					}
+					
+					switch (command.Command) {
+					case CommandEventType.SendData:
+						ProcessSendData((CommandSendData)command.CommandObject);
+						break;						
+					case CommandEventType.ReceiveData:
+						ProcessReceiveData((CommandReceiveData)command.CommandObject);
+						break;	
+					case CommandEventType.GamerJoined:
+						ProcessGamerJoined((CommandGamerJoined)command.CommandObject);
+						break;
+					case CommandEventType.GamerLeft:
+						ProcessGamerLeft((CommandGamerLeft)command.CommandObject);
+						break;
+					case CommandEventType.SessionStateChange:
+						ProcessSessionStateChange((CommandSessionStateChange)command.CommandObject);
+						break;
+					case CommandEventType.GamerStateChange:
+						ProcessGamerStateChange((CommandGamerStateChange)command.CommandObject);
+						break;							
+					
+					}					
+				}
+			} 
+			catch (Exception exc) {
+                if (exc != null)
+                {
+#if DEBUG				
+				Console.WriteLine("Error in NetworkSession Update: " + exc.Message);
+#endif
+                }
+			}
+			finally {
+			}
+		}
+		
+		private void ProcessGamerStateChange(CommandGamerStateChange command) 
+		{
+			
+			networkPeer.SendGamerStateChange(command.Gamer);	
+		}
+		
+		private void ProcessSendData(CommandSendData command)
+		{
+			networkPeer.SendData(command.data, command.options);
+
+			CommandReceiveData crd = new CommandReceiveData (command.sender.RemoteUniqueIdentifier,
+								command.data);
+			crd.gamer = command.sender;
+			foreach(LocalNetworkGamer gamer in _localGamers) {
+				gamer.receivedData.Enqueue(crd);
+			}
+		}
+		
+		private void ProcessReceiveData(CommandReceiveData command)
+		{
+			
+			// first let's look up the gamer that sent the data
+			foreach (NetworkGamer gamer in _allGamers) {
+				if (gamer.RemoteUniqueIdentifier == command.remoteUniqueIdentifier)
+					command.gamer = gamer;
+			}
+			
+			// for some reason this is null sometimes
+			//  this needs to be looked into instead of the
+			//  check below
+			if (command.gamer == null)
+				return;
+			
+			// now we loop through each of our local gamers and add the command
+			// to be processed.
+			foreach (LocalNetworkGamer localGamer in LocalGamers) {
+				lock (localGamer.receivedData) {
+					localGamer.receivedData.Enqueue(command);
+				}
+			}
+			
+		}
+		
+		private void ProcessSessionStateChange(CommandSessionStateChange command)
+		{
+			if (sessionState == command.NewState)
+				return;
+			
+			sessionState = command.NewState;
+			
+			switch (command.NewState) {
+			case NetworkSessionState.Ended:
+				
+				ResetReady();
+
+                // Have to find an example of how this is used so that I can figure out how to pass
+                // the EndReason
+                EventHelpers.Raise(this, SessionEnded, new NetworkSessionEndedEventArgs(NetworkSessionEndReason.HostEndedSession));
+				break;
+			case NetworkSessionState.Playing:
+				
+				EventHelpers.Raise(this, GameStarted, new GameStartedEventArgs());
+				break;
+			}
+			
+			// if changing from playing to lobby
+			if (command.NewState == NetworkSessionState.Lobby && command.OldState == NetworkSessionState.Playing) {
+				ResetReady();
+				EventHelpers.Raise(this, GameEnded, new GameEndedEventArgs());
+			}
+		}
+		
+		private void ProcessGamerJoined(CommandGamerJoined command) 
+		{
+			NetworkGamer gamer;
+			
+			if ((command.State & GamerStates.Local) != 0) {
+				gamer = new LocalNetworkGamer(this, (byte)command.InternalIndex, command.State);
+				_allGamers.AddGamer(gamer);
+				_localGamers.AddGamer((LocalNetworkGamer)gamer);
+
+				// Note - This might be in the wrong place for certain connections
+				//  Take a look at HoneycombRush tut for debugging later.
+				if (Gamer.SignedInGamers.Count >= _localGamers.Count)
+					((LocalNetworkGamer)gamer).SignedInGamer = Gamer.SignedInGamers[_localGamers.Count - 1];
+				
+				// We will attach a property change handler to local gamers
+				//  se that we can broadcast the change to other peers.
+				gamer.PropertyChanged += HandleGamerPropertyChanged;				
+			}
+			else {
+				gamer = new NetworkGamer (this, (byte)command.InternalIndex, command.State);
+				gamer.DisplayName = command.DisplayName;
+				gamer.Gamertag = command.GamerTag;
+				gamer.RemoteUniqueIdentifier = command.remoteUniqueIdentifier;
+				_allGamers.AddGamer(gamer);
+				_remoteGamers.AddGamer(gamer);
+			}
+			
+			if ((command.State & GamerStates.Host) != 0)
+				hostingGamer = gamer;
+			
+			gamer.Machine = new NetworkMachine();
+			gamer.Machine.Gamers.AddGamer(gamer);
+			//gamer.IsReady = true;
+			
+			EventHelpers.Raise(this, GamerJoined, new GamerJoinedEventArgs(gamer));
+			
+			if (networkPeer !=  null && (command.State & GamerStates.Local) == 0) {
+				
+				networkPeer.SendPeerIntroductions(gamer);
+			}
+			
+			if (networkPeer != null)
+			{
+				networkPeer.UpdateLiveSession(this);
+			}
+			
+			
+		}
+		
+		private void ProcessGamerLeft(CommandGamerLeft command) 
+		{
+			NetworkGamer gamer;
+			
+			for (int x = 0; x < _remoteGamers.Count; x++) {
+				if (_remoteGamers[x].RemoteUniqueIdentifier == command.remoteUniqueIdentifier) {
+					gamer = _remoteGamers[x];
+					_remoteGamers.RemoveGamer(gamer);
+					_allGamers.RemoveGamer(gamer);
+					EventHelpers.Raise(this, GamerLeft, new GamerLeftEventArgs(gamer));
+				}
+				
+			}
+			
+			if (networkPeer != null)
+			{
+				networkPeer.UpdateLiveSession(this);
+			}
+		}		
+
+		void HandleGamerPropertyChanged (object sender, System.ComponentModel.PropertyChangedEventArgs e)
+		{
+			NetworkGamer gamer = sender as NetworkGamer;
+			if (gamer == null)
+				return;
+			
+			// If the gamer is local then we need to broadcast that change to all other
+			// connected peers.  This is a double check here as we should only be handling 
+			//  property changes for local gamers for now.
+			if (gamer.IsLocal) {
+				CommandGamerStateChange sc = new CommandGamerStateChange(gamer);
+				CommandEvent cmd = new CommandEvent(sc);
+				commandQueue.Enqueue(cmd);
+			}
+		}
+		
+		#region Properties
+		public GamerCollection<NetworkGamer> AllGamers { 
+			get {
+				return _allGamers;
+			}
+		}
+
+		bool _AllowHostMigration = false;
+
+		public bool AllowHostMigration { 
+			get {
+				return _AllowHostMigration;
+			}
+			set {
+				if (_AllowHostMigration != value) {
+					_AllowHostMigration = value;
+				}
+			}
+		}
+
+		bool _AllowJoinInProgress = false;
+
+		public bool AllowJoinInProgress { 
+			get {
+				return _AllowJoinInProgress;
+			}
+			set {
+				if (_AllowJoinInProgress != value) {
+					_AllowJoinInProgress = value;
+				}
+			}
+		}
+
+        /*
+		public int BytesPerSecondReceived { 
+			get {
+				throw new NotImplementedException ();
+			}
+		}
+
+		public int BytesPerSecondSent { 
+			get {
+				throw new NotImplementedException ();
+			}
+		}
+        */
+
+		public NetworkGamer Host { 
+			get {
+				return hostingGamer;
+			}
+		}
+
+		bool _isDisposed = false;
+
+		public bool IsDisposed { 
+			get {
+				return _isDisposed; // TODO (this.kernelHandle == 0);
+			}
+		}
+
+		public bool IsEveryoneReady { 
+			get {
+				if (_allGamers.Count == 0)
+					return false;
+				foreach (NetworkGamer gamer in _allGamers) {
+					if (!gamer.IsReady) {
+						return false;
+					}
+				}
+				return true;
+			}
+		}
+
+		public bool IsHost { 
+			get {
+				return isHost;
+			}
+		}
+
+		public GamerCollection<LocalNetworkGamer> LocalGamers { 
+			get {
+				return _localGamers;
+			}
+		}	
+
+		public int MaxGamers { 
+			get {
+				return maxGamers;
+			}
+			set {
+				maxGamers = value;
+			}
+		}		
+
+		public GamerCollection<NetworkGamer> PreviousGamers {
+			get {
+				return _previousGamers;
+			}
+		}
+
+		public int PrivateGamerSlots { 
+			get {
+				return privateGamerSlots;
+			}
+			set {
+				privateGamerSlots = value;
+			}
+		}	
+
+		public GamerCollection<NetworkGamer> RemoteGamers {
+			get {
+				return _remoteGamers;
+			}
+		}
+
+		public NetworkSessionProperties SessionProperties {
+			get {
+				return sessionProperties;
+			}
+		}	
+
+		public NetworkSessionState SessionState {
+			get {
+				return sessionState;
+			}
+		}
+
+		public NetworkSessionType SessionType {
+			get {
+				return sessionType;
+			}
+		}
+
+        private TimeSpan defaultSimulatedLatency = new TimeSpan(0, 0, 0);
+
+		public TimeSpan SimulatedLatency {
+			get {
+#if DEBUG
+                if (networkPeer != null)
+                {
+                    return networkPeer.SimulatedLatency;
+                }
+#endif
+                return defaultSimulatedLatency;				
+			}
+			set {
+                defaultSimulatedLatency = value;
+#if DEBUG
+                if (networkPeer != null)
+                {
+                    networkPeer.SimulatedLatency = value;
+                }
+#endif
+                
+			}
+		}
+
+        private float simulatedPacketLoss = 0.0f;
+
+		public float SimulatedPacketLoss {
+			get {
+                if (networkPeer != null)
+                {
+                    simulatedPacketLoss = networkPeer.SimulatedPacketLoss;                   
+                }
+                return simulatedPacketLoss;
+			}
+			set {
+                if (networkPeer != null) networkPeer.SimulatedPacketLoss = value;
+                simulatedPacketLoss = value;
+			}
+		}			
+
+		#endregion
+
+		#region Events
+		public event EventHandler<GameEndedEventArgs> GameEnded;
+		public event EventHandler<GamerJoinedEventArgs> GamerJoined;
+		public event EventHandler<GamerLeftEventArgs> GamerLeft;
+		public event EventHandler<GameStartedEventArgs> GameStarted;
+		public event EventHandler<HostChangedEventArgs> HostChanged;
+		public static event EventHandler<InviteAcceptedEventArgs> InviteAccepted;
+		public event EventHandler<NetworkSessionEndedEventArgs> SessionEnded;
+
+        private bool SuppressEventHandlerWarningsUntilEventsAreProperlyImplemented()
+        {
+            return
+                HostChanged != null &&
+                InviteAccepted != null;
+        }
+
+		#endregion
+
+        internal static void Exit()
+        {
+            if (Net.NetworkSession.activeSessions != null && Net.NetworkSession.activeSessions.Count > 0)
+            {
+                foreach (Net.NetworkSession session in Net.NetworkSession.activeSessions)
+                {
+                    if (!session.IsDisposed)
+                    {
+                        session.Dispose();
+                    }
+                }
+            }
+        }
+    }
+
+	public class GameEndedEventArgs : EventArgs
+	{
+	}
+
+	public class GamerJoinedEventArgs : EventArgs
+	{
+		private NetworkGamer gamer;
+
+		public GamerJoinedEventArgs (NetworkGamer aGamer)
+		{
+			gamer = aGamer;
+		}
+
+		public NetworkGamer Gamer { 
+			get {
+				return gamer;
+			}
+		}
+	}
+
+	public class GamerLeftEventArgs : EventArgs
+	{
+		private NetworkGamer gamer;
+
+		public GamerLeftEventArgs (NetworkGamer aGamer)
+		{
+			gamer = aGamer;
+		}
+
+		public NetworkGamer Gamer { 
+			get {
+				return gamer;
+			}
+		}
+	}
+
+	public class GameStartedEventArgs : EventArgs
+	{
+
+	}
+
+	public class HostChangedEventArgs : EventArgs
+	{
+		private NetworkGamer newHost;
+		private NetworkGamer oldHost;
+
+		public HostChangedEventArgs (NetworkGamer aNewHost, NetworkGamer aOldHost)
+		{
+			newHost = aNewHost;
+			oldHost = aOldHost;
+		}
+
+		public NetworkGamer NewHost { 
+			get {
+				return newHost;
+			}
+		}
+
+		public NetworkGamer OldHost { 
+			get {
+				return oldHost;
+			}
+		}
+	}
+
+	public class InviteAcceptedEventArgs : EventArgs
+	{
+		private SignedInGamer gamer;
+
+		public InviteAcceptedEventArgs (SignedInGamer aGamer)
+		{
+			gamer = aGamer;
+		}
+
+		public SignedInGamer Gamer { 
+			get {
+				return gamer;
+			}
+		}
+
+		public bool IsCurrentSession { 
+			get {
+				return false;
+			}
+		}
+	}
+
+	public class NetworkSessionEndedEventArgs : EventArgs
+	{
+		NetworkSessionEndReason endReason;
+
+		public NetworkSessionEndedEventArgs (NetworkSessionEndReason aEndReason)
+		{
+			endReason = aEndReason;
+		}
+
+		public NetworkSessionEndReason EndReason { 
+			get {
+				return endReason;
+			}
+		}
+
+	}
+}
diff --git a/MonoGame.Framework/Net/NetworkSessionEndReason.cs b/MonoGame.Framework/Net/NetworkSessionEndReason.cs
new file mode 100644
index 00000000000..a6c17e32b84
--- /dev/null
+++ b/MonoGame.Framework/Net/NetworkSessionEndReason.cs
@@ -0,0 +1,55 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+#region Using clause
+using System;
+#endregion Using clause
+
+
+namespace Microsoft.Xna.Framework.Net
+{
+	public enum NetworkSessionEndReason
+	{
+		ClientSignedOut,	// This client player has signed out of session.
+		HostEndedSession,	// The host left the session, removing all active players.
+		RemovedByHost,		// The host removed this client player from the session.
+		Disconnected,		// Network connectivity problems ended the session
+	}
+}
diff --git a/MonoGame.Framework/Net/NetworkSessionJoinError.cs b/MonoGame.Framework/Net/NetworkSessionJoinError.cs
new file mode 100644
index 00000000000..49fd8aebb90
--- /dev/null
+++ b/MonoGame.Framework/Net/NetworkSessionJoinError.cs
@@ -0,0 +1,53 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+using System;
+
+namespace Microsoft.Xna.Framework.Net
+{
+
+
+	public enum NetworkSessionJoinError
+	{
+		SessionNotFound, 	// The session could not be found. Occurs if the session has ended after the matchmaking query but before the client joined, of if there is no network connectivity between the client and session host machines.
+		SessionNotJoinable,	// The session exists but is not joinable. Occurs if the session is in progress but does not allow gamers to join a session in progress.
+		SessionFull,		// The session exists but does not have any open slots for local signed-in gamers.
+	}
+}
diff --git a/MonoGame.Framework/Net/NetworkSessionJoinException.cs b/MonoGame.Framework/Net/NetworkSessionJoinException.cs
new file mode 100644
index 00000000000..282883168a6
--- /dev/null
+++ b/MonoGame.Framework/Net/NetworkSessionJoinException.cs
@@ -0,0 +1,91 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+using System;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework.Net
+{
+#if WINDOWS_UAP
+    [DataContract]
+#else
+    [Serializable]
+#endif
+	public class NetworkSessionJoinException : NetworkException
+	{
+		#region Methods
+		public NetworkSessionJoinException()
+		{
+		}
+		
+		public NetworkSessionJoinException( string message ): base(message)
+		{
+			
+		}
+		
+		public NetworkSessionJoinException (string message, Exception innerException) : base( message, innerException)
+		{
+			
+		}
+		
+		public NetworkSessionJoinException (string message, NetworkSessionJoinError joinError ):base(message)
+		{
+			_JoinError = JoinError;
+		}
+		#endregion
+		
+		#region Properties
+		NetworkSessionJoinError _JoinError;
+		public NetworkSessionJoinError JoinError 
+		{ 
+			get
+			{
+				return _JoinError;
+			}
+			
+			set
+			{
+				if (_JoinError != value)
+					JoinError = value;
+			}
+		}
+		#endregion
+	}
+}
diff --git a/MonoGame.Framework/Net/NetworkSessionProperties.cs b/MonoGame.Framework/Net/NetworkSessionProperties.cs
new file mode 100644
index 00000000000..e6b5bb0d6b9
--- /dev/null
+++ b/MonoGame.Framework/Net/NetworkSessionProperties.cs
@@ -0,0 +1,100 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+#region Using clause
+using System;
+using System.Collections.Generic;
+
+using Microsoft.Xna.Framework.GamerServices;
+
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+	public class NetworkSessionProperties : List<Nullable<int>>
+	{
+
+		// The NetworkSessionProperies can contain up to eight interger values
+		//  from all the documentation I can find as well as tests that have been done
+		//  to confirm this.
+		public NetworkSessionProperties () : base(8)
+		{
+			this.Add (null);
+			this.Add (null);
+			this.Add (null);
+			this.Add (null);
+			this.Add (null);
+			this.Add (null);
+			this.Add (null);
+			this.Add (null);
+
+		}
+		
+		public static void WriteProperties (NetworkSessionProperties properties, int[] propertyData) 
+		{
+			
+			for (int x = 0; x < 8; x++) {
+				if ((properties != null) && properties[x].HasValue) {
+					// flag it as having a value
+					propertyData[x*2] = 1;
+					propertyData[x*2+1] = properties[x].Value;
+					
+				}
+				else {
+					// flag it as not having a value
+					propertyData[x*2] = 0;
+					propertyData[x*2+1] = 0;
+					
+				}
+			}
+		}
+		
+		public static void ReadProperties (NetworkSessionProperties properties, int[] propertyData) 
+		{
+			for (int x = 0; x < 8; x++) {
+				// set it to null to start
+				properties[x] = null;
+				// and only if the flag is turned on do we have a value.
+				if (propertyData[x*2] > 0)
+					properties[x] = propertyData[x*2+1];
+			}
+		}		
+	}
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Net/NetworkSessionState.cs b/MonoGame.Framework/Net/NetworkSessionState.cs
new file mode 100644
index 00000000000..cb012fdd48f
--- /dev/null
+++ b/MonoGame.Framework/Net/NetworkSessionState.cs
@@ -0,0 +1,57 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+#region Using clause
+using System;
+
+#endregion Using clause
+
+
+namespace Microsoft.Xna.Framework.Net
+{
+
+
+	public enum NetworkSessionState
+	{
+		Lobby,	 // The local machine joins the session, waiting in the pregame lobby. The GameStarted event is raised when gameplay begins.
+		Playing, // The local machine joins the session, currently in the middle of gameplay. The GameEnded event is raised when the session returns to the lobby.
+		Ended,	 // The local machine has left the current session or the session has ended. The SessionEnded event is raised at this time. The event's arguments describe the reason for the session ending.
+	}
+}
diff --git a/MonoGame.Framework/Net/NetworkSessionType.cs b/MonoGame.Framework/Net/NetworkSessionType.cs
new file mode 100644
index 00000000000..427c35fcd2b
--- /dev/null
+++ b/MonoGame.Framework/Net/NetworkSessionType.cs
@@ -0,0 +1,58 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009-2010 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+#region Using clause
+using System;
+
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+	public enum NetworkSessionType
+	{
+		Local,    		// Does not involve any networking traffic, but can be used for split-screen gaming on a single Xbox 360 console. Creating a local network session may also make it easier to share code between local and online game modes. 
+
+		SystemLink,	// Connect multiple Xbox 360 consoles or computers over a local subnet. These machines do not require a connection to Xbox LIVE or any LIVE accounts. However, connection to machines on different subnets is not allowed.
+				// If you are a Creators Club developer testing your game, you can use this type to connect an Xbox 360 console to a computer. However, cross-platform networking is not supported in games distributed to non-–Creators Club community players.
+
+		PlayerMatch,	// Uses the Xbox LIVE servers. This enables connection to other machines over the Internet. It requires a LIVE Silver Membership for Windows-based games or a LIVE Gold membership for Xbox 360 games. Games in development will also require an XNA Creators Club premium membership. While in trial mode, Indie games downloaded from Xbox LIVE Markeplace will not have access to LIVE matchmaking.
+		Ranked,		// All session matches are ranked. This option is available only for commercial games that have passed Xbox LIVE certification. Due to the competitive nature of the gameplay, this session type does not support join-in-progress.
+	}
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Net/PacketReader.cs b/MonoGame.Framework/Net/PacketReader.cs
new file mode 100644
index 00000000000..60552612dee
--- /dev/null
+++ b/MonoGame.Framework/Net/PacketReader.cs
@@ -0,0 +1,191 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+#region Using clause
+using System;
+using System.IO;
+
+using Microsoft.Xna.Framework.Graphics;
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+
+
+	public class PacketReader : BinaryReader
+	{
+		
+		// Read comments within the PacketWriter
+		#region Constructors
+		public PacketReader() : this(0)
+		{
+		}
+		
+		
+		public PacketReader(int capacity) : base(new MemoryStream(0))
+		{
+			
+		}
+		#endregion
+		
+		#region Methods
+		internal byte[] Data
+		{
+			get {
+				MemoryStream stream = (MemoryStream)this.BaseStream;
+				return stream.GetBuffer();
+			}			
+			set {
+				MemoryStream ms = (MemoryStream)this.BaseStream;
+				ms.Write(value, 0, value.Length);
+			}
+		}
+		
+		public Color ReadColor()
+		{
+			Color newColor = Color.Transparent;
+			newColor.PackedValue = this.ReadUInt32();
+			return newColor;
+		}
+		
+		public override double ReadDouble()
+		{
+			return this.ReadDouble();
+		}
+		
+		public Matrix ReadMatrix()
+		{
+			Matrix matrix = new Matrix();
+			
+			matrix.M11 = this.ReadSingle();
+			matrix.M12 = this.ReadSingle();
+			matrix.M13 = this.ReadSingle();
+			matrix.M14 = this.ReadSingle();
+			
+			matrix.M21 = this.ReadSingle();
+			matrix.M22 = this.ReadSingle();
+			matrix.M23 = this.ReadSingle();
+			matrix.M24 = this.ReadSingle();
+			
+			matrix.M31 = this.ReadSingle();
+			matrix.M32 = this.ReadSingle();
+			matrix.M33 = this.ReadSingle();
+			matrix.M34 = this.ReadSingle();
+			
+			matrix.M41 = this.ReadSingle();
+			matrix.M42 = this.ReadSingle();
+			matrix.M43 = this.ReadSingle();
+			matrix.M44 = this.ReadSingle();
+
+			return matrix;
+		}
+		
+		public Quaternion ReadQuaternion()
+		{
+			Quaternion quat = new Quaternion();
+			quat.X = this.ReadSingle();
+			quat.Y = this.ReadSingle();
+			quat.Z = this.ReadSingle();
+			quat.W = this.ReadSingle();
+			
+			return quat;
+			
+		}
+		
+//		public override float ReadSingle()
+//		{
+//			return this.ReadSingle();
+//		}
+		
+		public Vector2 ReadVector2()
+		{
+			Vector2 vect = new Vector2();
+			vect.X = this.ReadSingle();
+			vect.Y = this.ReadSingle();
+			
+			return vect;		}
+		
+		public Vector3 ReadVector3()
+		{
+			Vector3 vect = new Vector3();
+			vect.X = this.ReadSingle();
+			vect.Y = this.ReadSingle();
+			vect.Z = this.ReadSingle();
+			
+			return vect;
+		}
+			
+		public Vector4 ReadVector4()
+		{
+			Vector4 vect = new Vector4();
+			vect.X = this.ReadSingle();
+			vect.Y = this.ReadSingle();
+			vect.Z = this.ReadSingle();
+			vect.W = this.ReadSingle();
+			
+			return vect;
+		}
+		
+		internal void Reset(int size) {
+			MemoryStream ms = (MemoryStream)BaseStream;
+			ms.SetLength(size);
+			ms.Position = 0;
+		}
+		#endregion
+		
+		#region Properties
+		public int Length { 
+			get {
+				return (int)BaseStream.Length;
+			}
+		}
+
+		public int Position { 
+			get {
+				return (int)BaseStream.Position;
+			}
+			set {
+				if (BaseStream.Position != value)
+					BaseStream.Position = value;
+			} 
+		}
+		#endregion
+	}
+}
diff --git a/MonoGame.Framework/Net/PacketWriter.cs b/MonoGame.Framework/Net/PacketWriter.cs
new file mode 100644
index 00000000000..b10ea59bd61
--- /dev/null
+++ b/MonoGame.Framework/Net/PacketWriter.cs
@@ -0,0 +1,176 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+#region Using clause
+using System;
+using System.IO;
+
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Graphics.PackedVector;
+
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+	public class PacketWriter : BinaryWriter
+	{
+	
+		// I thought about using an array but that means more code in my opinion and it does not make sense
+		//  since the memory stream is perfect for this.
+		// Using a memory stream also fits nicely with the constructors see:
+		// http://msdn.microsoft.com/en-us/library/microsoft.xna.framework.net.packetwriter.packetwriter.aspx
+		// We will see when testing begins.
+		#region Constructors
+		public PacketWriter () : this (0)
+		{
+		}
+
+		public PacketWriter (int capacity) : base ( new MemoryStream(capacity))
+		{
+		}
+
+		#endregion
+
+		#region Methods
+		public void Write (Color Value)
+		{
+			base.Write (Value.PackedValue);
+		}
+
+		public override void Write (double Value)
+		{
+			base.Write (Value);
+		}
+		
+		public void Write (Matrix Value)
+		{
+			// After looking at a captured packet it looks like all the values of 
+			//  the matrix are written.  This is different than the Lidgren XNAExtensions
+			base.Write (Value.M11);
+			base.Write (Value.M12);
+			base.Write (Value.M13);
+			base.Write (Value.M14);
+			base.Write (Value.M21);
+			base.Write (Value.M22);
+			base.Write (Value.M23);
+			base.Write (Value.M24);
+			base.Write (Value.M31);
+			base.Write (Value.M32);
+			base.Write (Value.M33);
+			base.Write (Value.M34);
+			base.Write (Value.M41);
+			base.Write (Value.M42);
+			base.Write (Value.M43);
+			base.Write (Value.M44);
+		}
+
+		public void Write (Quaternion Value)
+		{
+			// This may need to be corrected as have no test for it
+			base.Write(Value.X);
+			base.Write(Value.Y);
+			base.Write(Value.Z);
+			base.Write(Value.W);			
+			
+		}
+
+		public override void Write (float Value)
+		{
+			base.Write(Value);
+		}
+
+		public void Write (Vector2 Value)
+		{
+			base.Write(Value.X);
+			base.Write(Value.Y);
+		}
+
+		public void Write (Vector3 Value)
+		{
+			base.Write(Value.X);
+			base.Write(Value.Y);
+			base.Write(Value.Z);
+		}
+
+		public void Write (Vector4 Value)
+		{
+			base.Write(Value.X);
+			base.Write(Value.Y);
+			base.Write(Value.Z);
+			base.Write(Value.W);
+		}
+
+		#endregion
+		
+		internal byte[] Data
+		{
+			get {
+				MemoryStream stream = (MemoryStream)this.BaseStream;
+				return stream.GetBuffer();
+			}
+		}
+		
+		#region Properties
+		public int Length { 
+			get {
+				return (int)BaseStream.Length;
+			}
+		}
+
+		public int Position { 
+			get {
+				return (int)BaseStream.Position;
+			}
+			set {
+				if (BaseStream.Position != value)
+					BaseStream.Position = value;
+			} 
+		}
+		
+		internal void Reset() 
+		{
+			MemoryStream stream = (MemoryStream)this.BaseStream;
+			stream.SetLength(0);
+			stream.Position = 0;
+			
+		}
+		#endregion
+	}
+}
diff --git a/MonoGame.Framework/Net/QualityOfService.cs b/MonoGame.Framework/Net/QualityOfService.cs
new file mode 100644
index 00000000000..dafd5e84fc3
--- /dev/null
+++ b/MonoGame.Framework/Net/QualityOfService.cs
@@ -0,0 +1,93 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License 
+
+#region Using clause
+using System;
+
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+	public class QualityOfService
+	{
+		#region Properties
+		public TimeSpan AverageRoundtripTime 
+		{ 
+			get
+			{ 
+				return TimeSpan.MinValue;
+			}
+		}
+		
+		public int BytesPerSecondDownstream 
+		{ 
+			get
+			{ 
+				return 0;
+			}
+		}
+		
+		public int BytesPerSecondUpstream  
+		{ 
+			get
+			{ 
+				return 0;
+			}
+		}
+		
+		public bool IsAvailable 
+		{ 
+			get
+			{ 
+				return false;
+			}
+		}
+		
+		public TimeSpan MinimumRoundtripTime 
+		{ 
+			get
+			{ 
+				return TimeSpan.MinValue;
+			}
+		}
+		#endregion Properties
+		
+	}
+}
diff --git a/MonoGame.Framework/Net/SendDataOptions.cs b/MonoGame.Framework/Net/SendDataOptions.cs
new file mode 100644
index 00000000000..e4ab47d27b6
--- /dev/null
+++ b/MonoGame.Framework/Net/SendDataOptions.cs
@@ -0,0 +1,56 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License 
+
+#region Using clause
+using System;
+
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+	public enum SendDataOptions
+	{
+		None,
+		Reliable,
+		InOrder,
+		ReliableInOrder,
+		Chat,
+	}
+}
diff --git a/MonoGame.Framework/Plane.cs b/MonoGame.Framework/Plane.cs
new file mode 100644
index 00000000000..77681636c4f
--- /dev/null
+++ b/MonoGame.Framework/Plane.cs
@@ -0,0 +1,311 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework
+{
+	internal class PlaneHelper
+    {
+        /// <summary>
+        /// Returns a value indicating what side (positive/negative) of a plane a point is
+        /// </summary>
+        /// <param name="point">The point to check with</param>
+        /// <param name="plane">The plane to check against</param>
+        /// <returns>Greater than zero if on the positive side, less than zero if on the negative size, 0 otherwise</returns>
+        public static float ClassifyPoint(ref Vector3 point, ref Plane plane)
+        {
+            return point.X * plane.Normal.X + point.Y * plane.Normal.Y + point.Z * plane.Normal.Z + plane.D;
+        }
+
+        /// <summary>
+        /// Returns the perpendicular distance from a point to a plane
+        /// </summary>
+        /// <param name="point">The point to check</param>
+        /// <param name="plane">The place to check</param>
+        /// <returns>The perpendicular distance from the point to the plane</returns>
+        public static float PerpendicularDistance(ref Vector3 point, ref Plane plane)
+        {
+            // dist = (ax + by + cz + d) / sqrt(a*a + b*b + c*c)
+            return (float)Math.Abs((plane.Normal.X * point.X + plane.Normal.Y * point.Y + plane.Normal.Z * point.Z)
+                                    / Math.Sqrt(plane.Normal.X * plane.Normal.X + plane.Normal.Y * plane.Normal.Y + plane.Normal.Z * plane.Normal.Z));
+        }
+    }
+	
+    [DataContract]
+    [DebuggerDisplay("{DebugDisplayString,nq}")]
+    public struct Plane : IEquatable<Plane>
+    {
+        #region Public Fields
+
+        [DataMember]
+        public float D;
+
+        [DataMember]
+        public Vector3 Normal;
+
+        #endregion Public Fields
+
+
+        #region Constructors
+
+        public Plane(Vector4 value)
+            : this(new Vector3(value.X, value.Y, value.Z), value.W)
+        {
+
+        }
+
+        public Plane(Vector3 normal, float d)
+        {
+            Normal = normal;
+            D = d;
+        }
+
+        public Plane(Vector3 a, Vector3 b, Vector3 c)
+        {
+            Vector3 ab = b - a;
+            Vector3 ac = c - a;
+
+            Vector3 cross = Vector3.Cross(ab, ac);
+            Vector3.Normalize(ref cross, out Normal);
+            D = -(Vector3.Dot(Normal, a));
+        }
+
+        public Plane(float a, float b, float c, float d)
+            : this(new Vector3(a, b, c), d)
+        {
+
+        }
+
+        /// <summary>
+        /// Create a <see cref="Plane"/> that contains the specified point and has the specified <see cref="Normal"/> vector.
+        /// </summary>
+        /// <param name="pointOnPlane">A point the created <see cref="Plane"/> should contain.</param>
+        /// <param name="normal">The normal of the plane.</param>
+        public Plane(Vector3 pointOnPlane, Vector3 normal)
+        {
+            Normal = normal;
+            D = -(
+                pointOnPlane.X * normal.X +
+                pointOnPlane.Y * normal.Y +
+                pointOnPlane.Z * normal.Z
+            );
+        }
+
+        #endregion Constructors
+
+
+        #region Public Methods
+
+        public float Dot(Vector4 value)
+        {
+            return ((((this.Normal.X * value.X) + (this.Normal.Y * value.Y)) + (this.Normal.Z * value.Z)) + (this.D * value.W));
+        }
+
+        public void Dot(ref Vector4 value, out float result)
+        {
+            result = (((this.Normal.X * value.X) + (this.Normal.Y * value.Y)) + (this.Normal.Z * value.Z)) + (this.D * value.W);
+        }
+
+        public float DotCoordinate(Vector3 value)
+        {
+            return ((((this.Normal.X * value.X) + (this.Normal.Y * value.Y)) + (this.Normal.Z * value.Z)) + this.D);
+        }
+
+        public void DotCoordinate(ref Vector3 value, out float result)
+        {
+            result = (((this.Normal.X * value.X) + (this.Normal.Y * value.Y)) + (this.Normal.Z * value.Z)) + this.D;
+        }
+
+        public float DotNormal(Vector3 value)
+        {
+            return (((this.Normal.X * value.X) + (this.Normal.Y * value.Y)) + (this.Normal.Z * value.Z));
+        }
+
+        public void DotNormal(ref Vector3 value, out float result)
+        {
+            result = ((this.Normal.X * value.X) + (this.Normal.Y * value.Y)) + (this.Normal.Z * value.Z);
+        }
+
+        /// <summary>
+        /// Transforms a normalized plane by a matrix.
+        /// </summary>
+        /// <param name="plane">The normalized plane to transform.</param>
+        /// <param name="matrix">The transformation matrix.</param>
+        /// <returns>The transformed plane.</returns>
+        public static Plane Transform(Plane plane, Matrix matrix)
+        {
+            Plane result;
+            Transform(ref plane, ref matrix, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Transforms a normalized plane by a matrix.
+        /// </summary>
+        /// <param name="plane">The normalized plane to transform.</param>
+        /// <param name="matrix">The transformation matrix.</param>
+        /// <param name="result">The transformed plane.</param>
+        public static void Transform(ref Plane plane, ref Matrix matrix, out Plane result)
+        {
+            // See "Transforming Normals" in http://www.glprogramming.com/red/appendixf.html
+            // for an explanation of how this works.
+
+            Matrix transformedMatrix;
+            Matrix.Invert(ref matrix, out transformedMatrix);
+            Matrix.Transpose(ref transformedMatrix, out transformedMatrix);
+
+            var vector = new Vector4(plane.Normal, plane.D);
+
+            Vector4 transformedVector;
+            Vector4.Transform(ref vector, ref transformedMatrix, out transformedVector);
+
+            result = new Plane(transformedVector);
+        }
+
+        /// <summary>
+        /// Transforms a normalized plane by a quaternion rotation.
+        /// </summary>
+        /// <param name="plane">The normalized plane to transform.</param>
+        /// <param name="rotation">The quaternion rotation.</param>
+        /// <returns>The transformed plane.</returns>
+        public static Plane Transform(Plane plane, Quaternion rotation)
+        {
+            Plane result;
+            Transform(ref plane, ref rotation, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Transforms a normalized plane by a quaternion rotation.
+        /// </summary>
+        /// <param name="plane">The normalized plane to transform.</param>
+        /// <param name="rotation">The quaternion rotation.</param>
+        /// <param name="result">The transformed plane.</param>
+        public static void Transform(ref Plane plane, ref Quaternion rotation, out Plane result)
+        {
+            Vector3.Transform(ref plane.Normal, ref rotation, out result.Normal);
+            result.D = plane.D;
+        }
+
+        public void Normalize()
+        {
+            float length = Normal.Length();
+            float factor =  1f / length;            
+            Vector3.Multiply(ref Normal, factor, out Normal);
+            D = D * factor;
+        }
+
+        public static Plane Normalize(Plane value)
+        {
+			Plane ret;
+			Normalize(ref value, out ret);
+			return ret;
+        }
+
+        public static void Normalize(ref Plane value, out Plane result)
+        {
+            float length = value.Normal.Length();
+            float factor =  1f / length;            
+            Vector3.Multiply(ref value.Normal, factor, out result.Normal);
+            result.D = value.D * factor;
+        }
+
+        public static bool operator !=(Plane plane1, Plane plane2)
+        {
+            return !plane1.Equals(plane2);
+        }
+
+        public static bool operator ==(Plane plane1, Plane plane2)
+        {
+            return plane1.Equals(plane2);
+        }
+
+        public override bool Equals(object other)
+        {
+            return (other is Plane) ? this.Equals((Plane)other) : false;
+        }
+
+        public bool Equals(Plane other)
+        {
+            return ((Normal == other.Normal) && (D == other.D));
+        }
+
+        public override int GetHashCode()
+        {
+            return Normal.GetHashCode() ^ D.GetHashCode();
+        }
+
+        public PlaneIntersectionType Intersects(BoundingBox box)
+        {
+            return box.Intersects(this);
+        }
+
+        public void Intersects(ref BoundingBox box, out PlaneIntersectionType result)
+        {
+            box.Intersects (ref this, out result);
+        }
+
+        public PlaneIntersectionType Intersects(BoundingFrustum frustum)
+        {
+            return frustum.Intersects(this);
+        }
+
+        public PlaneIntersectionType Intersects(BoundingSphere sphere)
+        {
+            return sphere.Intersects(this);
+        }
+
+        public void Intersects(ref BoundingSphere sphere, out PlaneIntersectionType result)
+        {
+            sphere.Intersects(ref this, out result);
+        }
+
+        internal PlaneIntersectionType Intersects(ref Vector3 point)
+        {
+            float distance;
+            DotCoordinate(ref point, out distance);
+
+            if (distance > 0)
+                return PlaneIntersectionType.Front;
+
+            if (distance < 0)
+                return PlaneIntersectionType.Back;
+
+            return PlaneIntersectionType.Intersecting;
+        }
+
+        internal string DebugDisplayString
+        {
+            get
+            {
+                return string.Concat(
+                    this.Normal.DebugDisplayString, "  ",
+                    this.D.ToString()
+                    );
+            }
+        }
+
+        public override string ToString()
+        {
+            return "{Normal:" + Normal + " D:" + D + "}";
+        }
+
+        /// <summary>
+        /// Deconstruction method for <see cref="Plane"/>.
+        /// </summary>
+        /// <param name="normal"></param>
+        /// <param name="d"></param>
+        public void Deconstruct(out Vector3 normal, out float d)
+        {
+            normal = Normal;
+            d = D;
+        }
+
+        #endregion
+    }
+}
+
diff --git a/MonoGame.Framework/PlaneIntersectionType.cs b/MonoGame.Framework/PlaneIntersectionType.cs
new file mode 100644
index 00000000000..b5399353e2e
--- /dev/null
+++ b/MonoGame.Framework/PlaneIntersectionType.cs
@@ -0,0 +1,25 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Defines the intersection between a <see cref="Plane"/> and a bounding volume.
+    /// </summary>
+    public enum PlaneIntersectionType
+    {
+        /// <summary>
+        /// There is no intersection, the bounding volume is in the negative half space of the plane.
+        /// </summary>
+        Front,
+        /// <summary>
+        /// There is no intersection, the bounding volume is in the positive half space of the plane.
+        /// </summary>
+        Back,
+        /// <summary>
+        /// The plane is intersected.
+        /// </summary>
+        Intersecting
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/PlayerIndex.cs b/MonoGame.Framework/PlayerIndex.cs
new file mode 100644
index 00000000000..328b20f3f09
--- /dev/null
+++ b/MonoGame.Framework/PlayerIndex.cs
@@ -0,0 +1,29 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework
+{   
+    /// <summary>
+    /// Defines the index of player for various MonoGame components.
+    /// </summary>
+    public enum PlayerIndex
+    {
+        /// <summary>
+        /// The first player index.
+        /// </summary>
+        One = 0,
+        /// <summary>
+        /// The second player index.
+        /// </summary>
+        Two = 1,
+        /// <summary>
+        /// The third player index.
+        /// </summary>
+        Three = 2,
+        /// <summary>
+        /// The fourth player index.
+        /// </summary>
+        Four = 3
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Point.cs b/MonoGame.Framework/Point.cs
new file mode 100644
index 00000000000..2e768f59368
--- /dev/null
+++ b/MonoGame.Framework/Point.cs
@@ -0,0 +1,234 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Describes a 2D-point.
+    /// </summary>
+    [DataContract]
+    [DebuggerDisplay("{DebugDisplayString,nq}")]
+    public struct Point : IEquatable<Point>
+    {
+        #region Private Fields
+
+        private static readonly Point zeroPoint = new Point();
+
+        #endregion
+
+        #region Public Fields
+
+        /// <summary>
+        /// The x coordinate of this <see cref="Point"/>.
+        /// </summary>
+        [DataMember]
+        public int X;
+
+        /// <summary>
+        /// The y coordinate of this <see cref="Point"/>.
+        /// </summary>
+        [DataMember]
+        public int Y;
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Returns a <see cref="Point"/> with coordinates 0, 0.
+        /// </summary>
+        public static Point Zero
+        {
+            get { return zeroPoint; }
+        }
+
+        #endregion
+
+        #region Internal Properties
+
+        internal string DebugDisplayString
+        {
+            get
+            {
+                return string.Concat(
+                    this.X.ToString(), "  ",
+                    this.Y.ToString()
+                );
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Constructs a point with X and Y from two values.
+        /// </summary>
+        /// <param name="x">The x coordinate in 2d-space.</param>
+        /// <param name="y">The y coordinate in 2d-space.</param>
+        public Point(int x, int y)
+        {
+            this.X = x;
+            this.Y = y;
+        }
+
+        /// <summary>
+        /// Constructs a point with X and Y set to the same value.
+        /// </summary>
+        /// <param name="value">The x and y coordinates in 2d-space.</param>
+        public Point(int value)
+        {
+            this.X = value;
+            this.Y = value;
+        }
+
+        #endregion
+
+        #region Operators
+
+        /// <summary>
+        /// Adds two points.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Point"/> on the left of the add sign.</param>
+        /// <param name="value2">Source <see cref="Point"/> on the right of the add sign.</param>
+        /// <returns>Sum of the points.</returns>
+        public static Point operator +(Point value1, Point value2)
+        {
+            return new Point(value1.X + value2.X, value1.Y + value2.Y);
+        }
+
+        /// <summary>
+        /// Subtracts a <see cref="Point"/> from a <see cref="Point"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Point"/> on the left of the sub sign.</param>
+        /// <param name="value2">Source <see cref="Point"/> on the right of the sub sign.</param>
+        /// <returns>Result of the subtraction.</returns>
+        public static Point operator -(Point value1, Point value2)
+        {
+            return new Point(value1.X - value2.X, value1.Y - value2.Y);
+        }
+
+        /// <summary>
+        /// Multiplies the components of two points by each other.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Point"/> on the left of the mul sign.</param>
+        /// <param name="value2">Source <see cref="Point"/> on the right of the mul sign.</param>
+        /// <returns>Result of the multiplication.</returns>
+        public static Point operator *(Point value1, Point value2)
+        {
+            return new Point(value1.X * value2.X, value1.Y * value2.Y);
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Point"/> by the components of another <see cref="Point"/>.
+        /// </summary>
+        /// <param name="source">Source <see cref="Point"/> on the left of the div sign.</param>
+        /// <param name="divisor">Divisor <see cref="Point"/> on the right of the div sign.</param>
+        /// <returns>The result of dividing the points.</returns>
+        public static Point operator /(Point source, Point divisor)
+        {
+            return new Point(source.X / divisor.X, source.Y / divisor.Y);
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="Point"/> instances are equal.
+        /// </summary>
+        /// <param name="a"><see cref="Point"/> instance on the left of the equal sign.</param>
+        /// <param name="b"><see cref="Point"/> instance on the right of the equal sign.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Point a, Point b)
+        {
+            return a.Equals(b);
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="Point"/> instances are not equal.
+        /// </summary>
+        /// <param name="a"><see cref="Point"/> instance on the left of the not equal sign.</param>
+        /// <param name="b"><see cref="Point"/> instance on the right of the not equal sign.</param>
+        /// <returns><c>true</c> if the instances are not equal; <c>false</c> otherwise.</returns>	
+        public static bool operator !=(Point a, Point b)
+        {
+            return !a.Equals(b);
+        }
+
+        #endregion
+
+        #region Public methods
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Object"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="Object"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is Point) && Equals((Point)obj);
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Point"/>.
+        /// </summary>
+        /// <param name="other">The <see cref="Point"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public bool Equals(Point other)
+        {
+            return ((X == other.X) && (Y == other.Y));
+        }
+
+        /// <summary>
+        /// Gets the hash code of this <see cref="Point"/>.
+        /// </summary>
+        /// <returns>Hash code of this <see cref="Point"/>.</returns>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hash = 17;
+                hash = hash * 23 + X.GetHashCode();
+                hash = hash * 23 + Y.GetHashCode();
+                return hash;
+            }
+
+        }
+
+        /// <summary>
+        /// Returns a <see cref="String"/> representation of this <see cref="Point"/> in the format:
+        /// {X:[<see cref="X"/>] Y:[<see cref="Y"/>]}
+        /// </summary>
+        /// <returns><see cref="String"/> representation of this <see cref="Point"/>.</returns>
+        public override string ToString()
+        {
+            return "{X:" + X + " Y:" + Y + "}";
+        }
+
+        /// <summary>
+        /// Gets a <see cref="Vector2"/> representation for this object.
+        /// </summary>
+        /// <returns>A <see cref="Vector2"/> representation for this object.</returns>
+        public Vector2 ToVector2()
+        {
+            return new Vector2(X, Y);
+        }
+
+        /// <summary>
+        /// Deconstruction method for <see cref="Point"/>.
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        public void Deconstruct(out int x, out int y)
+        {
+            x = X;
+            y = Y;
+        }
+
+        #endregion
+    }
+}
+
+
diff --git a/MonoGame.Framework/PreparingDeviceSettingsEventArgs.cs b/MonoGame.Framework/PreparingDeviceSettingsEventArgs.cs
new file mode 100644
index 00000000000..7a265696269
--- /dev/null
+++ b/MonoGame.Framework/PreparingDeviceSettingsEventArgs.cs
@@ -0,0 +1,29 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// The arguments to the <see cref="GraphicsDeviceManager.PreparingDeviceSettings"/> event.
+    /// </summary>
+    public class PreparingDeviceSettingsEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Create a new instance of the event.
+        /// </summary>
+        /// <param name="graphicsDeviceInformation">The default settings to be used in device creation.</param>
+        public PreparingDeviceSettingsEventArgs(GraphicsDeviceInformation graphicsDeviceInformation)
+        {
+            GraphicsDeviceInformation = graphicsDeviceInformation;
+        }
+
+        /// <summary>
+        /// The default settings that will be used in device creation.
+        /// </summary>
+        public GraphicsDeviceInformation GraphicsDeviceInformation { get; private set; }
+    }
+}
+
diff --git a/MonoGame.Framework/PrimaryThreadLoader.cs b/MonoGame.Framework/PrimaryThreadLoader.cs
new file mode 100644
index 00000000000..3d45cc50972
--- /dev/null
+++ b/MonoGame.Framework/PrimaryThreadLoader.cs
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Interface used to add an object to be loaded on the primary thread
+    /// </summary>
+    interface IPrimaryThreadLoaded
+    {
+        bool Load();
+    }
+
+    /// <summary>
+    /// Static class that is called before every draw to load resources that need to finish loading on the primary thread
+    /// </summary>
+    internal static class PrimaryThreadLoader
+    {
+        private static readonly object ListLockObject = new object();
+        private static readonly List<IPrimaryThreadLoaded> NeedToLoad = new List<IPrimaryThreadLoaded>(); 
+        private static readonly List<IPrimaryThreadLoaded> RemoveList = new List<IPrimaryThreadLoaded>();
+        private static DateTime _lastUpdate = DateTime.UtcNow;
+
+        public static void AddToList(IPrimaryThreadLoaded primaryThreadLoaded)
+        {
+            lock (ListLockObject)
+            {
+                NeedToLoad.Add(primaryThreadLoaded);
+            }
+        }
+
+        public static void RemoveFromList(IPrimaryThreadLoaded primaryThreadLoaded)
+        {
+            lock (ListLockObject)
+            {
+                NeedToLoad.Remove(primaryThreadLoaded);
+            }
+        }
+
+        public static void RemoveFromList(List<IPrimaryThreadLoaded> primaryThreadLoadeds)
+        {
+            lock (ListLockObject)
+            {
+                foreach (var primaryThreadLoaded in primaryThreadLoadeds)
+                {
+                    NeedToLoad.Remove(primaryThreadLoaded);
+                }
+            }
+        }
+
+        public static void Clear()
+        {
+            lock(ListLockObject)
+            {
+                NeedToLoad.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Loops through list and loads the item.  If successful, it is removed from the list.
+        /// </summary>
+        public static void DoLoads()
+        {
+            if((DateTime.UtcNow - _lastUpdate).Milliseconds < 250) return;
+
+            _lastUpdate = DateTime.UtcNow;
+            lock (ListLockObject)
+            {
+                for (int i = 0; i < NeedToLoad.Count; i++)
+                {
+                    var primaryThreadLoaded = NeedToLoad[i];
+                    if (primaryThreadLoaded.Load())
+                    {
+                        RemoveList.Add(primaryThreadLoaded);
+                    }
+                }
+
+                for (int i = 0; i < RemoveList.Count; i++)
+                {
+                    var primaryThreadLoaded = RemoveList[i];
+                    NeedToLoad.Remove(primaryThreadLoaded);
+                }
+
+                RemoveList.Clear();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Properties/AssemblyInfo.Android.cs b/MonoGame.Framework/Properties/AssemblyInfo.Android.cs
new file mode 100644
index 00000000000..c79d8f8a7d8
--- /dev/null
+++ b/MonoGame.Framework/Properties/AssemblyInfo.Android.cs
@@ -0,0 +1,7 @@
+using System.Reflection;
+
+// Specific platform information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("MonoGame for Android")]
diff --git a/MonoGame.Framework/Properties/AssemblyInfo.Angle.cs b/MonoGame.Framework/Properties/AssemblyInfo.Angle.cs
new file mode 100644
index 00000000000..b2846da7584
--- /dev/null
+++ b/MonoGame.Framework/Properties/AssemblyInfo.Angle.cs
@@ -0,0 +1,7 @@
+using System.Reflection;
+
+// Specific platform information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("MonoGame for Angle")]
diff --git a/MonoGame.Framework/Properties/AssemblyInfo.DesktopGL.cs b/MonoGame.Framework/Properties/AssemblyInfo.DesktopGL.cs
new file mode 100644
index 00000000000..cb962d9395b
--- /dev/null
+++ b/MonoGame.Framework/Properties/AssemblyInfo.DesktopGL.cs
@@ -0,0 +1,7 @@
+using System.Reflection;
+
+// Specific platform information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("MonoGame for all OpenGL Desktop Platforms")]
diff --git a/MonoGame.Framework/Properties/AssemblyInfo.Mac.cs b/MonoGame.Framework/Properties/AssemblyInfo.Mac.cs
new file mode 100644
index 00000000000..ddcd9c63311
--- /dev/null
+++ b/MonoGame.Framework/Properties/AssemblyInfo.Mac.cs
@@ -0,0 +1,7 @@
+using System.Reflection;
+
+// Specific platform information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("MonoGame for Mac OS X")]
diff --git a/MonoGame.Framework/Properties/AssemblyInfo.TVOS.cs b/MonoGame.Framework/Properties/AssemblyInfo.TVOS.cs
new file mode 100644
index 00000000000..68ca3e18bc7
--- /dev/null
+++ b/MonoGame.Framework/Properties/AssemblyInfo.TVOS.cs
@@ -0,0 +1,7 @@
+using System.Reflection;
+
+// Specific platform information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("MonoGame for tvOS")]
diff --git a/MonoGame.Framework/Properties/AssemblyInfo.UniversalWindowsPlatform.cs b/MonoGame.Framework/Properties/AssemblyInfo.UniversalWindowsPlatform.cs
new file mode 100644
index 00000000000..c0866731077
--- /dev/null
+++ b/MonoGame.Framework/Properties/AssemblyInfo.UniversalWindowsPlatform.cs
@@ -0,0 +1,7 @@
+using System.Reflection;
+
+// Specific platform information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("MonoGame for Universal Windows Platform")]
diff --git a/MonoGame.Framework/Properties/AssemblyInfo.Web.cs b/MonoGame.Framework/Properties/AssemblyInfo.Web.cs
new file mode 100644
index 00000000000..b0a08469aa0
--- /dev/null
+++ b/MonoGame.Framework/Properties/AssemblyInfo.Web.cs
@@ -0,0 +1,7 @@
+using System.Reflection;
+
+// Specific platform information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("MonoGame for the Web")]
diff --git a/MonoGame.Framework/Properties/AssemblyInfo.Windows.cs b/MonoGame.Framework/Properties/AssemblyInfo.Windows.cs
new file mode 100644
index 00000000000..c8395acfd38
--- /dev/null
+++ b/MonoGame.Framework/Properties/AssemblyInfo.Windows.cs
@@ -0,0 +1,7 @@
+using System.Reflection;
+
+// Specific platform information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("MonoGame for Windows Desktop (DirectX)")]
diff --git a/MonoGame.Framework/Properties/AssemblyInfo.cs b/MonoGame.Framework/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000000..5890b29ca6f
--- /dev/null
+++ b/MonoGame.Framework/Properties/AssemblyInfo.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Resources;
+
+// Common information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("MonoGame Team")]
+[assembly: AssemblyProduct("MonoGame.Framework")]
+[assembly: AssemblyCopyright("Copyright © 2009-2016 MonoGame Team")]
+[assembly: AssemblyTrademark("MonoGame® is a registered trademark of the MonoGame Team")]
+[assembly: AssemblyCulture("")]
+
+// Mark the assembly as CLS compliant so it can be safely used in other .NET languages
+[assembly: CLSCompliant(true)]
+
+// Allow the content pipeline assembly to access
+// some of our internal helper methods that it needs.
+[assembly: InternalsVisibleTo("MonoGame.Framework.Content.Pipeline")]
+[assembly: InternalsVisibleTo("MonoGame.Framework.Net")]
+
+//Tests projects need access too
+[assembly: InternalsVisibleTo("MonoGameTests")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("81119db2-82a6-45fb-a366-63a08437b485")]
+
+// This was needed in WinRT releases to inform the system that we
+// don't need to load any language specific resources.
+[assembly: NeutralResourcesLanguageAttribute("en-US")]
+
+// Version information for the assembly which is automatically
+// set by our automated build process.
+[assembly: AssemblyVersion("0.0.0.0")]
+[assembly: AssemblyFileVersion("0.0.0.0")]
diff --git a/MonoGame.Framework/Properties/AssemblyInfo.iOS.cs b/MonoGame.Framework/Properties/AssemblyInfo.iOS.cs
new file mode 100644
index 00000000000..a23321bd522
--- /dev/null
+++ b/MonoGame.Framework/Properties/AssemblyInfo.iOS.cs
@@ -0,0 +1,7 @@
+using System.Reflection;
+
+// Specific platform information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("MonoGame for iOS")]
diff --git a/MonoGame.Framework/Quaternion.cs b/MonoGame.Framework/Quaternion.cs
new file mode 100644
index 00000000000..d29dd0b8e96
--- /dev/null
+++ b/MonoGame.Framework/Quaternion.cs
@@ -0,0 +1,1178 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// An efficient mathematical representation for three dimensional rotations.
+    /// </summary>
+    [DataContract]
+    [DebuggerDisplay("{DebugDisplayString,nq}")]
+    public struct Quaternion : IEquatable<Quaternion>
+    {
+        #region Private Fields
+
+        private static readonly Quaternion _identity = new Quaternion(0, 0, 0, 1);
+
+        #endregion
+
+        #region Public Fields
+
+        /// <summary>
+        /// The x coordinate of this <see cref="Quaternion"/>.
+        /// </summary>
+        [DataMember]
+        public float X;
+
+        /// <summary>
+        /// The y coordinate of this <see cref="Quaternion"/>.
+        /// </summary>
+        [DataMember]
+        public float Y;
+
+        /// <summary>
+        /// The z coordinate of this <see cref="Quaternion"/>.
+        /// </summary>
+        [DataMember]
+        public float Z;
+
+        /// <summary>
+        /// The rotation component of this <see cref="Quaternion"/>.
+        /// </summary>
+        [DataMember]
+        public float W;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Constructs a quaternion with X, Y, Z and W from four values.
+        /// </summary>
+        /// <param name="x">The x coordinate in 3d-space.</param>
+        /// <param name="y">The y coordinate in 3d-space.</param>
+        /// <param name="z">The z coordinate in 3d-space.</param>
+        /// <param name="w">The rotation component.</param>
+        public Quaternion(float x, float y, float z, float w)
+        {
+            this.X = x;
+            this.Y = y;
+            this.Z = z;
+            this.W = w;
+        }
+
+        /// <summary>
+        /// Constructs a quaternion with X, Y, Z from <see cref="Vector3"/> and rotation component from a scalar.
+        /// </summary>
+        /// <param name="value">The x, y, z coordinates in 3d-space.</param>
+        /// <param name="w">The rotation component.</param>
+        public Quaternion(Vector3 value, float w)
+        {
+            this.X = value.X;
+            this.Y = value.Y;
+            this.Z = value.Z;
+            this.W = w;
+        }
+
+        /// <summary>
+        /// Constructs a quaternion from <see cref="Vector4"/>.
+        /// </summary>
+        /// <param name="value">The x, y, z coordinates in 3d-space and the rotation component.</param>
+        public Quaternion(Vector4 value)
+        {
+            this.X = value.X;
+            this.Y = value.Y;
+            this.Z = value.Z;
+            this.W = value.W;
+        }
+
+        #endregion
+
+        #region Public Properties
+
+        /// <summary>
+        /// Returns a quaternion representing no rotation.
+        /// </summary>
+        public static Quaternion Identity
+        {
+            get{ return _identity; }
+        }
+
+        #endregion
+
+        #region Internal Properties
+
+        internal string DebugDisplayString
+        {
+            get
+            {
+                if (this == Quaternion._identity)
+                {
+                    return "Identity";
+                }
+
+                return string.Concat(
+                    this.X.ToString(), " ",
+                    this.Y.ToString(), " ",
+                    this.Z.ToString(), " ",
+                    this.W.ToString()
+                );
+            }
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        #region Add
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> that contains the sum of two quaternions.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="quaternion2">Source <see cref="Quaternion"/>.</param>
+        /// <returns>The result of the quaternion addition.</returns>
+        public static Quaternion Add(Quaternion quaternion1, Quaternion quaternion2)
+        {
+			Quaternion quaternion;
+			quaternion.X = quaternion1.X + quaternion2.X;
+			quaternion.Y = quaternion1.Y + quaternion2.Y;
+			quaternion.Z = quaternion1.Z + quaternion2.Z;
+			quaternion.W = quaternion1.W + quaternion2.W;
+			return quaternion;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> that contains the sum of two quaternions.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="quaternion2">Source <see cref="Quaternion"/>.</param>
+        /// <param name="result">The result of the quaternion addition as an output parameter.</param>
+        public static void Add(ref Quaternion quaternion1, ref Quaternion quaternion2, out Quaternion result)
+        {
+			result.X = quaternion1.X + quaternion2.X;
+			result.Y = quaternion1.Y + quaternion2.Y;
+			result.Z = quaternion1.Z + quaternion2.Z;
+			result.W = quaternion1.W + quaternion2.W;
+        }
+
+        #endregion
+
+        #region Concatenate
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> that contains concatenation between two quaternion.
+        /// </summary>
+        /// <param name="value1">The first <see cref="Quaternion"/> to concatenate.</param>
+        /// <param name="value2">The second <see cref="Quaternion"/> to concatenate.</param>
+        /// <returns>The result of rotation of <paramref name="value1"/> followed by <paramref name="value2"/> rotation.</returns>
+        public static Quaternion Concatenate(Quaternion value1, Quaternion value2)
+		{
+			Quaternion quaternion;
+
+            float x1 = value1.X;
+            float y1 = value1.Y;
+            float z1 = value1.Z;
+            float w1 = value1.W;
+
+            float x2 = value2.X;
+		    float y2 = value2.Y;
+		    float z2 = value2.Z;
+		    float w2 = value2.W;
+
+		    quaternion.X = ((x2 * w1) + (x1 * w2)) + ((y2 * z1) - (z2 * y1));
+		    quaternion.Y = ((y2 * w1) + (y1 * w2)) + ((z2 * x1) - (x2 * z1));
+		    quaternion.Z = ((z2 * w1) + (z1 * w2)) + ((x2 * y1) - (y2 * x1));
+		    quaternion.W = (w2 * w1) - (((x2 * x1) + (y2 * y1)) + (z2 * z1));
+
+		    return quaternion;
+		}
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> that contains concatenation between two quaternion.
+        /// </summary>
+        /// <param name="value1">The first <see cref="Quaternion"/> to concatenate.</param>
+        /// <param name="value2">The second <see cref="Quaternion"/> to concatenate.</param>
+        /// <param name="result">The result of rotation of <paramref name="value1"/> followed by <paramref name="value2"/> rotation as an output parameter.</param>
+        public static void Concatenate(ref Quaternion value1, ref Quaternion value2, out Quaternion result)
+		{
+            float x1 = value1.X;
+            float y1 = value1.Y;
+            float z1 = value1.Z;
+            float w1 = value1.W;
+
+            float x2 = value2.X;
+            float y2 = value2.Y;
+            float z2 = value2.Z;
+            float w2 = value2.W;
+
+            result.X = ((x2 * w1) + (x1 * w2)) + ((y2 * z1) - (z2 * y1));
+            result.Y = ((y2 * w1) + (y1 * w2)) + ((z2 * x1) - (x2 * z1));
+            result.Z = ((z2 * w1) + (z1 * w2)) + ((x2 * y1) - (y2 * x1));
+            result.W = (w2 * w1) - (((x2 * x1) + (y2 * y1)) + (z2 * z1));
+        }
+
+        #endregion
+
+        #region Conjugate
+
+        /// <summary>
+        /// Transforms this quaternion into its conjugated version.
+        /// </summary>
+        public void Conjugate()
+		{
+			X = -X;
+			Y = -Y;
+			Z = -Z;
+		}
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> that contains conjugated version of the specified quaternion.
+        /// </summary>
+        /// <param name="value">The quaternion which values will be used to create the conjugated version.</param>
+        /// <returns>The conjugate version of the specified quaternion.</returns>
+        public static Quaternion Conjugate(Quaternion value)
+		{
+			return new Quaternion(-value.X,-value.Y,-value.Z,value.W);
+		}
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> that contains conjugated version of the specified quaternion.
+        /// </summary>
+        /// <param name="value">The quaternion which values will be used to create the conjugated version.</param>
+        /// <param name="result">The conjugated version of the specified quaternion as an output parameter.</param>
+        public static void Conjugate(ref Quaternion value, out Quaternion result)
+		{
+			result.X = -value.X;
+			result.Y = -value.Y;
+			result.Z = -value.Z;
+			result.W = value.W;
+		}
+
+        #endregion
+
+        #region CreateFromAxisAngle
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> from the specified axis and angle.
+        /// </summary>
+        /// <param name="axis">The axis of rotation.</param>
+        /// <param name="angle">The angle in radians.</param>
+        /// <returns>The new quaternion builded from axis and angle.</returns>
+        public static Quaternion CreateFromAxisAngle(Vector3 axis, float angle)
+        {
+		    float half = angle * 0.5f;
+		    float sin = (float)Math.Sin(half);
+		    float cos = (float)Math.Cos(half);
+		    return new Quaternion(axis.X * sin, axis.Y * sin, axis.Z * sin, cos);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> from the specified axis and angle.
+        /// </summary>
+        /// <param name="axis">The axis of rotation.</param>
+        /// <param name="angle">The angle in radians.</param>
+        /// <param name="result">The new quaternion builded from axis and angle as an output parameter.</param>
+        public static void CreateFromAxisAngle(ref Vector3 axis, float angle, out Quaternion result)
+        {
+            float half = angle * 0.5f;
+		    float sin = (float)Math.Sin(half);
+		    float cos = (float)Math.Cos(half);
+		    result.X = axis.X * sin;
+		    result.Y = axis.Y * sin;
+		    result.Z = axis.Z * sin;
+		    result.W = cos;
+        }
+
+        #endregion
+
+        #region CreateFromRotationMatrix
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> from the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="matrix">The rotation matrix.</param>
+        /// <returns>A quaternion composed from the rotation part of the matrix.</returns>
+        public static Quaternion CreateFromRotationMatrix(Matrix matrix)
+        {
+            Quaternion quaternion;
+            float sqrt;
+            float half;
+            float scale = matrix.M11 + matrix.M22 + matrix.M33;
+
+		    if (scale > 0.0f)
+		    {
+                sqrt = (float)Math.Sqrt(scale + 1.0f);
+		        quaternion.W = sqrt * 0.5f;
+                sqrt = 0.5f / sqrt;
+
+		        quaternion.X = (matrix.M23 - matrix.M32) * sqrt;
+		        quaternion.Y = (matrix.M31 - matrix.M13) * sqrt;
+		        quaternion.Z = (matrix.M12 - matrix.M21) * sqrt;
+
+		        return quaternion;
+		    }
+		    if ((matrix.M11 >= matrix.M22) && (matrix.M11 >= matrix.M33))
+		    {
+                sqrt = (float) Math.Sqrt(1.0f + matrix.M11 - matrix.M22 - matrix.M33);
+                half = 0.5f / sqrt;
+
+		        quaternion.X = 0.5f * sqrt;
+		        quaternion.Y = (matrix.M12 + matrix.M21) * half;
+		        quaternion.Z = (matrix.M13 + matrix.M31) * half;
+		        quaternion.W = (matrix.M23 - matrix.M32) * half;
+
+		        return quaternion;
+		    }
+		    if (matrix.M22 > matrix.M33)
+		    {
+                sqrt = (float) Math.Sqrt(1.0f + matrix.M22 - matrix.M11 - matrix.M33);
+                half = 0.5f / sqrt;
+
+		        quaternion.X = (matrix.M21 + matrix.M12) * half;
+		        quaternion.Y = 0.5f * sqrt;
+		        quaternion.Z = (matrix.M32 + matrix.M23) * half;
+		        quaternion.W = (matrix.M31 - matrix.M13) * half;
+
+		        return quaternion;
+		    }
+            sqrt = (float) Math.Sqrt(1.0f + matrix.M33 - matrix.M11 - matrix.M22);
+		    half = 0.5f / sqrt;
+
+		    quaternion.X = (matrix.M31 + matrix.M13) * half;
+		    quaternion.Y = (matrix.M32 + matrix.M23) * half;
+		    quaternion.Z = 0.5f * sqrt;
+		    quaternion.W = (matrix.M12 - matrix.M21) * half;
+
+		    return quaternion;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> from the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="matrix">The rotation matrix.</param>
+        /// <param name="result">A quaternion composed from the rotation part of the matrix as an output parameter.</param>
+        public static void CreateFromRotationMatrix(ref Matrix matrix, out Quaternion result)
+        {
+            float sqrt;
+            float half;
+            float scale = matrix.M11 + matrix.M22 + matrix.M33;
+
+            if (scale > 0.0f)
+            {
+                sqrt = (float)Math.Sqrt(scale + 1.0f);
+                result.W = sqrt * 0.5f;
+                sqrt = 0.5f / sqrt;
+
+                result.X = (matrix.M23 - matrix.M32) * sqrt;
+                result.Y = (matrix.M31 - matrix.M13) * sqrt;
+                result.Z = (matrix.M12 - matrix.M21) * sqrt;
+            }
+            else
+            if ((matrix.M11 >= matrix.M22) && (matrix.M11 >= matrix.M33))
+            {
+                sqrt = (float)Math.Sqrt(1.0f + matrix.M11 - matrix.M22 - matrix.M33);
+                half = 0.5f / sqrt;
+
+                result.X = 0.5f * sqrt;
+                result.Y = (matrix.M12 + matrix.M21) * half;
+                result.Z = (matrix.M13 + matrix.M31) * half;
+                result.W = (matrix.M23 - matrix.M32) * half;
+            }
+            else if (matrix.M22 > matrix.M33)
+            {
+                sqrt = (float) Math.Sqrt(1.0f + matrix.M22 - matrix.M11 - matrix.M33);
+                half = 0.5f/sqrt;
+
+                result.X = (matrix.M21 + matrix.M12)*half;
+                result.Y = 0.5f*sqrt;
+                result.Z = (matrix.M32 + matrix.M23)*half;
+                result.W = (matrix.M31 - matrix.M13)*half;
+            }
+            else
+            {
+                sqrt = (float)Math.Sqrt(1.0f + matrix.M33 - matrix.M11 - matrix.M22);
+                half = 0.5f / sqrt;
+
+                result.X = (matrix.M31 + matrix.M13) * half;
+                result.Y = (matrix.M32 + matrix.M23) * half;
+                result.Z = 0.5f * sqrt;
+                result.W = (matrix.M12 - matrix.M21) * half;
+            }
+        }
+
+        #endregion
+
+        #region CreateFromYawPitchRoll
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> from the specified yaw, pitch and roll angles.
+        /// </summary>
+        /// <param name="yaw">Yaw around the y axis in radians.</param>
+        /// <param name="pitch">Pitch around the x axis in radians.</param>
+        /// <param name="roll">Roll around the z axis in radians.</param>
+        /// <returns>A new quaternion from the concatenated yaw, pitch, and roll angles.</returns>
+        public static Quaternion CreateFromYawPitchRoll(float yaw, float pitch, float roll)
+		{
+            float halfRoll = roll * 0.5f;
+            float halfPitch = pitch * 0.5f;
+            float halfYaw = yaw * 0.5f;
+
+            float sinRoll = (float)Math.Sin(halfRoll);
+            float cosRoll = (float)Math.Cos(halfRoll);
+            float sinPitch = (float)Math.Sin(halfPitch);
+            float cosPitch = (float)Math.Cos(halfPitch);
+            float sinYaw = (float)Math.Sin(halfYaw);
+            float cosYaw = (float)Math.Cos(halfYaw);
+
+            return new Quaternion((cosYaw * sinPitch * cosRoll) + (sinYaw * cosPitch * sinRoll),
+                                  (sinYaw * cosPitch * cosRoll) - (cosYaw * sinPitch * sinRoll),
+                                  (cosYaw * cosPitch * sinRoll) - (sinYaw * sinPitch * cosRoll),
+                                  (cosYaw * cosPitch * cosRoll) + (sinYaw * sinPitch * sinRoll));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> from the specified yaw, pitch and roll angles.
+        /// </summary>
+        /// <param name="yaw">Yaw around the y axis in radians.</param>
+        /// <param name="pitch">Pitch around the x axis in radians.</param>
+        /// <param name="roll">Roll around the z axis in radians.</param>
+        /// <param name="result">A new quaternion from the concatenated yaw, pitch, and roll angles as an output parameter.</param>
+ 		public static void CreateFromYawPitchRoll(float yaw, float pitch, float roll, out Quaternion result)
+		{
+            float halfRoll = roll * 0.5f;
+            float halfPitch = pitch * 0.5f;
+            float halfYaw = yaw * 0.5f;
+
+            float sinRoll = (float)Math.Sin(halfRoll);
+            float cosRoll = (float)Math.Cos(halfRoll);
+            float sinPitch = (float)Math.Sin(halfPitch);
+            float cosPitch = (float)Math.Cos(halfPitch);
+            float sinYaw = (float)Math.Sin(halfYaw);
+            float cosYaw = (float)Math.Cos(halfYaw);
+
+            result.X = (cosYaw * sinPitch * cosRoll) + (sinYaw * cosPitch * sinRoll);
+            result.Y = (sinYaw * cosPitch * cosRoll) - (cosYaw * sinPitch * sinRoll);
+            result.Z = (cosYaw * cosPitch * sinRoll) - (sinYaw * sinPitch * cosRoll);
+            result.W = (cosYaw * cosPitch * cosRoll) + (sinYaw * sinPitch * sinRoll);
+        }
+
+        #endregion
+
+        #region Divide
+
+        /// <summary>
+        /// Divides a <see cref="Quaternion"/> by the other <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="quaternion2">Divisor <see cref="Quaternion"/>.</param>
+        /// <returns>The result of dividing the quaternions.</returns>
+        public static Quaternion Divide(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            Quaternion quaternion;
+		    float x = quaternion1.X;
+		    float y = quaternion1.Y;
+		    float z = quaternion1.Z;
+		    float w = quaternion1.W;
+		    float num14 = (((quaternion2.X * quaternion2.X) + (quaternion2.Y * quaternion2.Y)) + (quaternion2.Z * quaternion2.Z)) + (quaternion2.W * quaternion2.W);
+		    float num5 = 1f / num14;
+		    float num4 = -quaternion2.X * num5;
+		    float num3 = -quaternion2.Y * num5;
+		    float num2 = -quaternion2.Z * num5;
+		    float num = quaternion2.W * num5;
+		    float num13 = (y * num2) - (z * num3);
+		    float num12 = (z * num4) - (x * num2);
+		    float num11 = (x * num3) - (y * num4);
+		    float num10 = ((x * num4) + (y * num3)) + (z * num2);
+		    quaternion.X = ((x * num) + (num4 * w)) + num13;
+		    quaternion.Y = ((y * num) + (num3 * w)) + num12;
+		    quaternion.Z = ((z * num) + (num2 * w)) + num11;
+		    quaternion.W = (w * num) - num10;
+		    return quaternion;
+        }
+
+        /// <summary>
+        /// Divides a <see cref="Quaternion"/> by the other <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="quaternion2">Divisor <see cref="Quaternion"/>.</param>
+        /// <param name="result">The result of dividing the quaternions as an output parameter.</param>
+        public static void Divide(ref Quaternion quaternion1, ref Quaternion quaternion2, out Quaternion result)
+        {
+            float x = quaternion1.X;
+		    float y = quaternion1.Y;
+		    float z = quaternion1.Z;
+		    float w = quaternion1.W;
+		    float num14 = (((quaternion2.X * quaternion2.X) + (quaternion2.Y * quaternion2.Y)) + (quaternion2.Z * quaternion2.Z)) + (quaternion2.W * quaternion2.W);
+		    float num5 = 1f / num14;
+		    float num4 = -quaternion2.X * num5;
+		    float num3 = -quaternion2.Y * num5;
+		    float num2 = -quaternion2.Z * num5;
+		    float num = quaternion2.W * num5;
+		    float num13 = (y * num2) - (z * num3);
+		    float num12 = (z * num4) - (x * num2);
+		    float num11 = (x * num3) - (y * num4);
+		    float num10 = ((x * num4) + (y * num3)) + (z * num2);
+		    result.X = ((x * num) + (num4 * w)) + num13;
+		    result.Y = ((y * num) + (num3 * w)) + num12;
+		    result.Z = ((z * num) + (num2 * w)) + num11;
+		    result.W = (w * num) - num10;
+        }
+
+        #endregion
+
+        #region Dot
+
+        /// <summary>
+        /// Returns a dot product of two quaternions.
+        /// </summary>
+        /// <param name="quaternion1">The first quaternion.</param>
+        /// <param name="quaternion2">The second quaternion.</param>
+        /// <returns>The dot product of two quaternions.</returns>
+        public static float Dot(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            return ((((quaternion1.X * quaternion2.X) + (quaternion1.Y * quaternion2.Y)) + (quaternion1.Z * quaternion2.Z)) + (quaternion1.W * quaternion2.W));
+        }
+
+        /// <summary>
+        /// Returns a dot product of two quaternions.
+        /// </summary>
+        /// <param name="quaternion1">The first quaternion.</param>
+        /// <param name="quaternion2">The second quaternion.</param>
+        /// <param name="result">The dot product of two quaternions as an output parameter.</param>
+        public static void Dot(ref Quaternion quaternion1, ref Quaternion quaternion2, out float result)
+        {
+            result = (((quaternion1.X * quaternion2.X) + (quaternion1.Y * quaternion2.Y)) + (quaternion1.Z * quaternion2.Z)) + (quaternion1.W * quaternion2.W);
+        }
+
+        #endregion
+
+        #region Equals
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Object"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="Object"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            if (obj is Quaternion)
+                return Equals((Quaternion)obj);
+            return false;
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="other">The <see cref="Quaternion"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public bool Equals(Quaternion other)
+        {
+			return X == other.X &&
+                   Y == other.Y &&
+                   Z == other.Z &&
+                   W == other.W;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Gets the hash code of this <see cref="Quaternion"/>.
+        /// </summary>
+        /// <returns>Hash code of this <see cref="Quaternion"/>.</returns>
+        public override int GetHashCode()
+        {
+            return X.GetHashCode() + Y.GetHashCode() + Z.GetHashCode() + W.GetHashCode();
+        }
+
+        #region Inverse
+
+        /// <summary>
+        /// Returns the inverse quaternion which represents the opposite rotation.
+        /// </summary>
+        /// <param name="quaternion">Source <see cref="Quaternion"/>.</param>
+        /// <returns>The inverse quaternion.</returns>
+        public static Quaternion Inverse(Quaternion quaternion)
+        {
+            Quaternion quaternion2;
+		    float num2 = (((quaternion.X * quaternion.X) + (quaternion.Y * quaternion.Y)) + (quaternion.Z * quaternion.Z)) + (quaternion.W * quaternion.W);
+		    float num = 1f / num2;
+		    quaternion2.X = -quaternion.X * num;
+		    quaternion2.Y = -quaternion.Y * num;
+		    quaternion2.Z = -quaternion.Z * num;
+		    quaternion2.W = quaternion.W * num;
+		    return quaternion2;
+        }
+
+        /// <summary>
+        /// Returns the inverse quaternion which represents the opposite rotation.
+        /// </summary>
+        /// <param name="quaternion">Source <see cref="Quaternion"/>.</param>
+        /// <param name="result">The inverse quaternion as an output parameter.</param>
+        public static void Inverse(ref Quaternion quaternion, out Quaternion result)
+        {
+            float num2 = (((quaternion.X * quaternion.X) + (quaternion.Y * quaternion.Y)) + (quaternion.Z * quaternion.Z)) + (quaternion.W * quaternion.W);
+		    float num = 1f / num2;
+		    result.X = -quaternion.X * num;
+		    result.Y = -quaternion.Y * num;
+		    result.Z = -quaternion.Z * num;
+		    result.W = quaternion.W * num;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Returns the magnitude of the quaternion components.
+        /// </summary>
+        /// <returns>The magnitude of the quaternion components.</returns>
+        public float Length()
+        {
+    		return (float) Math.Sqrt((X * X) + (Y * Y) + (Z * Z) + (W * W));
+        }
+
+        /// <summary>
+        /// Returns the squared magnitude of the quaternion components.
+        /// </summary>
+        /// <returns>The squared magnitude of the quaternion components.</returns>
+        public float LengthSquared()
+        {
+            return (X * X) + (Y * Y) + (Z * Z) + (W * W);
+        }
+
+        #region Lerp
+
+        /// <summary>
+        /// Performs a linear blend between two quaternions.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="quaternion2">Source <see cref="Quaternion"/>.</param>
+        /// <param name="amount">The blend amount where 0 returns <paramref name="quaternion1"/> and 1 <paramref name="quaternion2"/>.</param>
+        /// <returns>The result of linear blending between two quaternions.</returns>
+        public static Quaternion Lerp(Quaternion quaternion1, Quaternion quaternion2, float amount)
+        {
+            float num = amount;
+		    float num2 = 1f - num;
+		    Quaternion quaternion = new Quaternion();
+		    float num5 = (((quaternion1.X * quaternion2.X) + (quaternion1.Y * quaternion2.Y)) + (quaternion1.Z * quaternion2.Z)) + (quaternion1.W * quaternion2.W);
+		    if (num5 >= 0f)
+		    {
+		        quaternion.X = (num2 * quaternion1.X) + (num * quaternion2.X);
+		        quaternion.Y = (num2 * quaternion1.Y) + (num * quaternion2.Y);
+		        quaternion.Z = (num2 * quaternion1.Z) + (num * quaternion2.Z);
+		        quaternion.W = (num2 * quaternion1.W) + (num * quaternion2.W);
+		    }
+		    else
+		    {
+		        quaternion.X = (num2 * quaternion1.X) - (num * quaternion2.X);
+		        quaternion.Y = (num2 * quaternion1.Y) - (num * quaternion2.Y);
+		        quaternion.Z = (num2 * quaternion1.Z) - (num * quaternion2.Z);
+		        quaternion.W = (num2 * quaternion1.W) - (num * quaternion2.W);
+		    }
+		    float num4 = (((quaternion.X * quaternion.X) + (quaternion.Y * quaternion.Y)) + (quaternion.Z * quaternion.Z)) + (quaternion.W * quaternion.W);
+		    float num3 = 1f / ((float) Math.Sqrt((double) num4));
+		    quaternion.X *= num3;
+		    quaternion.Y *= num3;
+		    quaternion.Z *= num3;
+		    quaternion.W *= num3;
+		    return quaternion;
+        }
+
+        /// <summary>
+        /// Performs a linear blend between two quaternions.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="quaternion2">Source <see cref="Quaternion"/>.</param>
+        /// <param name="amount">The blend amount where 0 returns <paramref name="quaternion1"/> and 1 <paramref name="quaternion2"/>.</param>
+        /// <param name="result">The result of linear blending between two quaternions as an output parameter.</param>
+        public static void Lerp(ref Quaternion quaternion1, ref Quaternion quaternion2, float amount, out Quaternion result)
+        {
+            float num = amount;
+		    float num2 = 1f - num;
+		    float num5 = (((quaternion1.X * quaternion2.X) + (quaternion1.Y * quaternion2.Y)) + (quaternion1.Z * quaternion2.Z)) + (quaternion1.W * quaternion2.W);
+		    if (num5 >= 0f)
+		    {
+		        result.X = (num2 * quaternion1.X) + (num * quaternion2.X);
+		        result.Y = (num2 * quaternion1.Y) + (num * quaternion2.Y);
+		        result.Z = (num2 * quaternion1.Z) + (num * quaternion2.Z);
+		        result.W = (num2 * quaternion1.W) + (num * quaternion2.W);
+		    }
+		    else
+		    {
+		        result.X = (num2 * quaternion1.X) - (num * quaternion2.X);
+		        result.Y = (num2 * quaternion1.Y) - (num * quaternion2.Y);
+		        result.Z = (num2 * quaternion1.Z) - (num * quaternion2.Z);
+		        result.W = (num2 * quaternion1.W) - (num * quaternion2.W);
+		    }
+		    float num4 = (((result.X * result.X) + (result.Y * result.Y)) + (result.Z * result.Z)) + (result.W * result.W);
+		    float num3 = 1f / ((float) Math.Sqrt((double) num4));
+		    result.X *= num3;
+		    result.Y *= num3;
+		    result.Z *= num3;
+		    result.W *= num3;
+
+        }
+
+        #endregion
+
+        #region Slerp
+
+        /// <summary>
+        /// Performs a spherical linear blend between two quaternions.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="quaternion2">Source <see cref="Quaternion"/>.</param>
+        /// <param name="amount">The blend amount where 0 returns <paramref name="quaternion1"/> and 1 <paramref name="quaternion2"/>.</param>
+        /// <returns>The result of spherical linear blending between two quaternions.</returns>
+        public static Quaternion Slerp(Quaternion quaternion1, Quaternion quaternion2, float amount)
+        {
+            float num2;
+		    float num3;
+		    Quaternion quaternion;
+		    float num = amount;
+		    float num4 = (((quaternion1.X * quaternion2.X) + (quaternion1.Y * quaternion2.Y)) + (quaternion1.Z * quaternion2.Z)) + (quaternion1.W * quaternion2.W);
+		    bool flag = false;
+		    if (num4 < 0f)
+		    {
+		        flag = true;
+		        num4 = -num4;
+		    }
+		    if (num4 > 0.999999f)
+		    {
+		        num3 = 1f - num;
+		        num2 = flag ? -num : num;
+		    }
+		    else
+		    {
+		        float num5 = (float) Math.Acos((double) num4);
+		        float num6 = (float) (1.0 / Math.Sin((double) num5));
+		        num3 = ((float) Math.Sin((double) ((1f - num) * num5))) * num6;
+		        num2 = flag ? (((float) -Math.Sin((double) (num * num5))) * num6) : (((float) Math.Sin((double) (num * num5))) * num6);
+		    }
+		    quaternion.X = (num3 * quaternion1.X) + (num2 * quaternion2.X);
+		    quaternion.Y = (num3 * quaternion1.Y) + (num2 * quaternion2.Y);
+		    quaternion.Z = (num3 * quaternion1.Z) + (num2 * quaternion2.Z);
+		    quaternion.W = (num3 * quaternion1.W) + (num2 * quaternion2.W);
+		    return quaternion;
+        }
+
+        /// <summary>
+        /// Performs a spherical linear blend between two quaternions.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="quaternion2">Source <see cref="Quaternion"/>.</param>
+        /// <param name="amount">The blend amount where 0 returns <paramref name="quaternion1"/> and 1 <paramref name="quaternion2"/>.</param>
+        /// <param name="result">The result of spherical linear blending between two quaternions as an output parameter.</param>
+        public static void Slerp(ref Quaternion quaternion1, ref Quaternion quaternion2, float amount, out Quaternion result)
+        {
+            float num2;
+		    float num3;
+		    float num = amount;
+		    float num4 = (((quaternion1.X * quaternion2.X) + (quaternion1.Y * quaternion2.Y)) + (quaternion1.Z * quaternion2.Z)) + (quaternion1.W * quaternion2.W);
+		    bool flag = false;
+		    if (num4 < 0f)
+		    {
+		        flag = true;
+		        num4 = -num4;
+		    }
+		    if (num4 > 0.999999f)
+		    {
+		        num3 = 1f - num;
+		        num2 = flag ? -num : num;
+		    }
+		    else
+		    {
+		        float num5 = (float) Math.Acos((double) num4);
+		        float num6 = (float) (1.0 / Math.Sin((double) num5));
+		        num3 = ((float) Math.Sin((double) ((1f - num) * num5))) * num6;
+		        num2 = flag ? (((float) -Math.Sin((double) (num * num5))) * num6) : (((float) Math.Sin((double) (num * num5))) * num6);
+		    }
+		    result.X = (num3 * quaternion1.X) + (num2 * quaternion2.X);
+		    result.Y = (num3 * quaternion1.Y) + (num2 * quaternion2.Y);
+		    result.Z = (num3 * quaternion1.Z) + (num2 * quaternion2.Z);
+		    result.W = (num3 * quaternion1.W) + (num2 * quaternion2.W);
+        }
+
+        #endregion
+
+        #region Subtract
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> that contains subtraction of one <see cref="Quaternion"/> from another.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="quaternion2">Source <see cref="Quaternion"/>.</param>
+        /// <returns>The result of the quaternion subtraction.</returns>
+        public static Quaternion Subtract(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            Quaternion quaternion;
+		    quaternion.X = quaternion1.X - quaternion2.X;
+		    quaternion.Y = quaternion1.Y - quaternion2.Y;
+		    quaternion.Z = quaternion1.Z - quaternion2.Z;
+		    quaternion.W = quaternion1.W - quaternion2.W;
+		    return quaternion;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> that contains subtraction of one <see cref="Quaternion"/> from another.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="quaternion2">Source <see cref="Quaternion"/>.</param>
+        /// <param name="result">The result of the quaternion subtraction as an output parameter.</param>
+        public static void Subtract(ref Quaternion quaternion1, ref Quaternion quaternion2, out Quaternion result)
+        {
+            result.X = quaternion1.X - quaternion2.X;
+		    result.Y = quaternion1.Y - quaternion2.Y;
+		    result.Z = quaternion1.Z - quaternion2.Z;
+		    result.W = quaternion1.W - quaternion2.W;
+        }
+
+        #endregion
+
+        #region Multiply
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> that contains a multiplication of two quaternions.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="quaternion2">Source <see cref="Quaternion"/>.</param>
+        /// <returns>The result of the quaternion multiplication.</returns>
+        public static Quaternion Multiply(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            Quaternion quaternion;
+		    float x = quaternion1.X;
+		    float y = quaternion1.Y;
+		    float z = quaternion1.Z;
+		    float w = quaternion1.W;
+		    float num4 = quaternion2.X;
+		    float num3 = quaternion2.Y;
+		    float num2 = quaternion2.Z;
+		    float num = quaternion2.W;
+		    float num12 = (y * num2) - (z * num3);
+		    float num11 = (z * num4) - (x * num2);
+		    float num10 = (x * num3) - (y * num4);
+		    float num9 = ((x * num4) + (y * num3)) + (z * num2);
+		    quaternion.X = ((x * num) + (num4 * w)) + num12;
+		    quaternion.Y = ((y * num) + (num3 * w)) + num11;
+		    quaternion.Z = ((z * num) + (num2 * w)) + num10;
+		    quaternion.W = (w * num) - num9;
+		    return quaternion;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> that contains a multiplication of <see cref="Quaternion"/> and a scalar.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="scaleFactor">Scalar value.</param>
+        /// <returns>The result of the quaternion multiplication with a scalar.</returns>
+        public static Quaternion Multiply(Quaternion quaternion1, float scaleFactor)
+        {
+            Quaternion quaternion;
+		    quaternion.X = quaternion1.X * scaleFactor;
+		    quaternion.Y = quaternion1.Y * scaleFactor;
+		    quaternion.Z = quaternion1.Z * scaleFactor;
+		    quaternion.W = quaternion1.W * scaleFactor;
+		    return quaternion;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> that contains a multiplication of <see cref="Quaternion"/> and a scalar.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="scaleFactor">Scalar value.</param>
+        /// <param name="result">The result of the quaternion multiplication with a scalar as an output parameter.</param>
+        public static void Multiply(ref Quaternion quaternion1, float scaleFactor, out Quaternion result)
+        {
+            result.X = quaternion1.X * scaleFactor;
+		    result.Y = quaternion1.Y * scaleFactor;
+		    result.Z = quaternion1.Z * scaleFactor;
+		    result.W = quaternion1.W * scaleFactor;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Quaternion"/> that contains a multiplication of two quaternions.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/>.</param>
+        /// <param name="quaternion2">Source <see cref="Quaternion"/>.</param>
+        /// <param name="result">The result of the quaternion multiplication as an output parameter.</param>
+        public static void Multiply(ref Quaternion quaternion1, ref Quaternion quaternion2, out Quaternion result)
+        {
+            float x = quaternion1.X;
+		    float y = quaternion1.Y;
+		    float z = quaternion1.Z;
+		    float w = quaternion1.W;
+		    float num4 = quaternion2.X;
+		    float num3 = quaternion2.Y;
+		    float num2 = quaternion2.Z;
+		    float num = quaternion2.W;
+		    float num12 = (y * num2) - (z * num3);
+		    float num11 = (z * num4) - (x * num2);
+		    float num10 = (x * num3) - (y * num4);
+		    float num9 = ((x * num4) + (y * num3)) + (z * num2);
+		    result.X = ((x * num) + (num4 * w)) + num12;
+		    result.Y = ((y * num) + (num3 * w)) + num11;
+		    result.Z = ((z * num) + (num2 * w)) + num10;
+		    result.W = (w * num) - num9;
+        }
+
+        #endregion
+
+        #region Negate
+
+        /// <summary>
+        /// Flips the sign of the all the quaternion components.
+        /// </summary>
+        /// <param name="quaternion">Source <see cref="Quaternion"/>.</param>
+        /// <returns>The result of the quaternion negation.</returns>
+        public static Quaternion Negate(Quaternion quaternion)
+        {
+		    return new Quaternion(-quaternion.X, -quaternion.Y, -quaternion.Z, -quaternion.W);
+        }
+
+        /// <summary>
+        /// Flips the sign of the all the quaternion components.
+        /// </summary>
+        /// <param name="quaternion">Source <see cref="Quaternion"/>.</param>
+        /// <param name="result">The result of the quaternion negation as an output parameter.</param>
+        public static void Negate(ref Quaternion quaternion, out Quaternion result)
+        {
+            result.X = -quaternion.X;
+		    result.Y = -quaternion.Y;
+		    result.Z = -quaternion.Z;
+		    result.W = -quaternion.W;
+        }
+
+        #endregion
+
+        #region Normalize
+
+        /// <summary>
+        /// Scales the quaternion magnitude to unit length.
+        /// </summary>
+        public void Normalize()
+        {
+		    float num = 1f / ((float) Math.Sqrt((X * X) + (Y * Y) + (Z * Z) + (W * W)));
+		    X *= num;
+		    Y *= num;
+		    Z *= num;
+		    W *= num;
+        }
+
+        /// <summary>
+        /// Scales the quaternion magnitude to unit length.
+        /// </summary>
+        /// <param name="quaternion">Source <see cref="Quaternion"/>.</param>
+        /// <returns>The unit length quaternion.</returns>
+        public static Quaternion Normalize(Quaternion quaternion)
+        {
+            Quaternion result;
+		    float num = 1f / ((float) Math.Sqrt((quaternion.X * quaternion.X) + (quaternion.Y * quaternion.Y) + (quaternion.Z * quaternion.Z) + (quaternion.W * quaternion.W)));
+            result.X = quaternion.X * num;
+            result.Y = quaternion.Y * num;
+            result.Z = quaternion.Z * num;
+            result.W = quaternion.W * num;
+		    return result;
+        }
+
+        /// <summary>
+        /// Scales the quaternion magnitude to unit length.
+        /// </summary>
+        /// <param name="quaternion">Source <see cref="Quaternion"/>.</param>
+        /// <param name="result">The unit length quaternion an output parameter.</param>
+        public static void Normalize(ref Quaternion quaternion, out Quaternion result)
+        {
+		    float num = 1f / ((float) Math.Sqrt((quaternion.X * quaternion.X) + (quaternion.Y * quaternion.Y) + (quaternion.Z * quaternion.Z) + (quaternion.W * quaternion.W)));
+		    result.X = quaternion.X * num;
+		    result.Y = quaternion.Y * num;
+		    result.Z = quaternion.Z * num;
+		    result.W = quaternion.W * num;
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Returns a <see cref="String"/> representation of this <see cref="Quaternion"/> in the format:
+        /// {X:[<see cref="X"/>] Y:[<see cref="Y"/>] Z:[<see cref="Z"/>] W:[<see cref="W"/>]}
+        /// </summary>
+        /// <returns>A <see cref="String"/> representation of this <see cref="Quaternion"/>.</returns>
+        public override string ToString()
+        {
+            return "{X:" + X + " Y:" + Y + " Z:" + Z + " W:" + W + "}";
+        }
+
+        /// <summary>
+        /// Gets a <see cref="Vector4"/> representation for this object.
+        /// </summary>
+        /// <returns>A <see cref="Vector4"/> representation for this object.</returns>
+        public Vector4 ToVector4()
+        {
+            return new Vector4(X,Y,Z,W);
+        }
+
+        public void Deconstruct(out float x, out float y, out float z, out float w)
+        {
+            x = X;
+            y = Y;
+            z = Z;
+            w = W;
+        }
+
+        #endregion
+
+        #region Operators
+
+        /// <summary>
+        /// Adds two quaternions.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/> on the left of the add sign.</param>
+        /// <param name="quaternion2">Source <see cref="Quaternion"/> on the right of the add sign.</param>
+        /// <returns>Sum of the vectors.</returns>
+        public static Quaternion operator +(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            Quaternion quaternion;
+		    quaternion.X = quaternion1.X + quaternion2.X;
+		    quaternion.Y = quaternion1.Y + quaternion2.Y;
+		    quaternion.Z = quaternion1.Z + quaternion2.Z;
+		    quaternion.W = quaternion1.W + quaternion2.W;
+		    return quaternion;
+        }
+
+        /// <summary>
+        /// Divides a <see cref="Quaternion"/> by the other <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/> on the left of the div sign.</param>
+        /// <param name="quaternion2">Divisor <see cref="Quaternion"/> on the right of the div sign.</param>
+        /// <returns>The result of dividing the quaternions.</returns>
+        public static Quaternion operator /(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            Quaternion quaternion;
+		    float x = quaternion1.X;
+		    float y = quaternion1.Y;
+		    float z = quaternion1.Z;
+		    float w = quaternion1.W;
+		    float num14 = (((quaternion2.X * quaternion2.X) + (quaternion2.Y * quaternion2.Y)) + (quaternion2.Z * quaternion2.Z)) + (quaternion2.W * quaternion2.W);
+		    float num5 = 1f / num14;
+		    float num4 = -quaternion2.X * num5;
+		    float num3 = -quaternion2.Y * num5;
+		    float num2 = -quaternion2.Z * num5;
+		    float num = quaternion2.W * num5;
+		    float num13 = (y * num2) - (z * num3);
+		    float num12 = (z * num4) - (x * num2);
+		    float num11 = (x * num3) - (y * num4);
+		    float num10 = ((x * num4) + (y * num3)) + (z * num2);
+		    quaternion.X = ((x * num) + (num4 * w)) + num13;
+		    quaternion.Y = ((y * num) + (num3 * w)) + num12;
+		    quaternion.Z = ((z * num) + (num2 * w)) + num11;
+		    quaternion.W = (w * num) - num10;
+		    return quaternion;
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="Quaternion"/> instances are equal.
+        /// </summary>
+        /// <param name="quaternion1"><see cref="Quaternion"/> instance on the left of the equal sign.</param>
+        /// <param name="quaternion2"><see cref="Quaternion"/> instance on the right of the equal sign.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            return ((((quaternion1.X == quaternion2.X) && (quaternion1.Y == quaternion2.Y)) && (quaternion1.Z == quaternion2.Z)) && (quaternion1.W == quaternion2.W));
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="Quaternion"/> instances are not equal.
+        /// </summary>
+        /// <param name="quaternion1"><see cref="Quaternion"/> instance on the left of the not equal sign.</param>
+        /// <param name="quaternion2"><see cref="Quaternion"/> instance on the right of the not equal sign.</param>
+        /// <returns><c>true</c> if the instances are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            if (((quaternion1.X == quaternion2.X) && (quaternion1.Y == quaternion2.Y)) && (quaternion1.Z == quaternion2.Z))
+		    {
+		        return (quaternion1.W != quaternion2.W);
+		    }
+		    return true;
+        }
+
+        /// <summary>
+        /// Multiplies two quaternions.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Quaternion"/> on the left of the mul sign.</param>
+        /// <param name="quaternion2">Source <see cref="Quaternion"/> on the right of the mul sign.</param>
+        /// <returns>Result of the quaternions multiplication.</returns>
+        public static Quaternion operator *(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            Quaternion quaternion;
+		    float x = quaternion1.X;
+		    float y = quaternion1.Y;
+		    float z = quaternion1.Z;
+		    float w = quaternion1.W;
+		    float num4 = quaternion2.X;
+		    float num3 = quaternion2.Y;
+		    float num2 = quaternion2.Z;
+		    float num = quaternion2.W;
+		    float num12 = (y * num2) - (z * num3);
+		    float num11 = (z * num4) - (x * num2);
+		    float num10 = (x * num3) - (y * num4);
+		    float num9 = ((x * num4) + (y * num3)) + (z * num2);
+		    quaternion.X = ((x * num) + (num4 * w)) + num12;
+		    quaternion.Y = ((y * num) + (num3 * w)) + num11;
+		    quaternion.Z = ((z * num) + (num2 * w)) + num10;
+		    quaternion.W = (w * num) - num9;
+		    return quaternion;
+        }
+
+        /// <summary>
+        /// Multiplies the components of quaternion by a scalar.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Vector3"/> on the left of the mul sign.</param>
+        /// <param name="scaleFactor">Scalar value on the right of the mul sign.</param>
+        /// <returns>Result of the quaternion multiplication with a scalar.</returns>
+        public static Quaternion operator *(Quaternion quaternion1, float scaleFactor)
+        {
+            Quaternion quaternion;
+		    quaternion.X = quaternion1.X * scaleFactor;
+		    quaternion.Y = quaternion1.Y * scaleFactor;
+		    quaternion.Z = quaternion1.Z * scaleFactor;
+		    quaternion.W = quaternion1.W * scaleFactor;
+		    return quaternion;
+        }
+
+        /// <summary>
+        /// Subtracts a <see cref="Quaternion"/> from a <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="quaternion1">Source <see cref="Vector3"/> on the left of the sub sign.</param>
+        /// <param name="quaternion2">Source <see cref="Vector3"/> on the right of the sub sign.</param>
+        /// <returns>Result of the quaternion subtraction.</returns>
+        public static Quaternion operator -(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            Quaternion quaternion;
+		    quaternion.X = quaternion1.X - quaternion2.X;
+		    quaternion.Y = quaternion1.Y - quaternion2.Y;
+		    quaternion.Z = quaternion1.Z - quaternion2.Z;
+		    quaternion.W = quaternion1.W - quaternion2.W;
+		    return quaternion;
+
+        }
+
+        /// <summary>
+        /// Flips the sign of the all the quaternion components.
+        /// </summary>
+        /// <param name="quaternion">Source <see cref="Quaternion"/> on the right of the sub sign.</param>
+        /// <returns>The result of the quaternion negation.</returns>
+        public static Quaternion operator -(Quaternion quaternion)
+        {
+            Quaternion quaternion2;
+		    quaternion2.X = -quaternion.X;
+		    quaternion2.Y = -quaternion.Y;
+		    quaternion2.Z = -quaternion.Z;
+		    quaternion2.W = -quaternion.W;
+		    return quaternion2;
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Ray.cs b/MonoGame.Framework/Ray.cs
new file mode 100755
index 00000000000..daa6c34ecd1
--- /dev/null
+++ b/MonoGame.Framework/Ray.cs
@@ -0,0 +1,272 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework
+{
+    [DataContract]
+    [DebuggerDisplay("{DebugDisplayString,nq}")]
+    public struct Ray : IEquatable<Ray>
+    {
+        #region Public Fields
+
+        [DataMember]
+        public Vector3 Direction;
+      
+        [DataMember]
+        public Vector3 Position;
+
+        #endregion
+
+
+        #region Public Constructors
+
+        public Ray(Vector3 position, Vector3 direction)
+        {
+            this.Position = position;
+            this.Direction = direction;
+        }
+
+        #endregion
+
+
+        #region Public Methods
+
+        public override bool Equals(object obj)
+        {
+            return (obj is Ray) ? this.Equals((Ray)obj) : false;
+        }
+
+        
+        public bool Equals(Ray other)
+        {
+            return this.Position.Equals(other.Position) && this.Direction.Equals(other.Direction);
+        }
+
+        
+        public override int GetHashCode()
+        {
+            return Position.GetHashCode() ^ Direction.GetHashCode();
+        }
+
+        // adapted from http://www.scratchapixel.com/lessons/3d-basic-lessons/lesson-7-intersecting-simple-shapes/ray-box-intersection/
+        public float? Intersects(BoundingBox box)
+        {
+            const float Epsilon = 1e-6f;
+
+            float? tMin = null, tMax = null;
+
+            if (Math.Abs(Direction.X) < Epsilon)
+            {
+                if (Position.X < box.Min.X || Position.X > box.Max.X)
+                    return null;
+            }
+            else
+            {
+                tMin = (box.Min.X - Position.X) / Direction.X;
+                tMax = (box.Max.X - Position.X) / Direction.X;
+
+                if (tMin > tMax)
+                {
+                    var temp = tMin;
+                    tMin = tMax;
+                    tMax = temp;
+                }
+            }
+
+            if (Math.Abs(Direction.Y) < Epsilon)
+            {
+                if (Position.Y < box.Min.Y || Position.Y > box.Max.Y)
+                    return null;
+            }
+            else
+            {
+                var tMinY = (box.Min.Y - Position.Y) / Direction.Y;
+                var tMaxY = (box.Max.Y - Position.Y) / Direction.Y;
+
+                if (tMinY > tMaxY)
+                {
+                    var temp = tMinY;
+                    tMinY = tMaxY;
+                    tMaxY = temp;
+                }
+
+                if ((tMin.HasValue && tMin > tMaxY) || (tMax.HasValue && tMinY > tMax))
+                    return null;
+
+                if (!tMin.HasValue || tMinY > tMin) tMin = tMinY;
+                if (!tMax.HasValue || tMaxY < tMax) tMax = tMaxY;
+            }
+
+            if (Math.Abs(Direction.Z) < Epsilon)
+            {
+                if (Position.Z < box.Min.Z || Position.Z > box.Max.Z)
+                    return null;
+            }
+            else
+            {
+                var tMinZ = (box.Min.Z - Position.Z) / Direction.Z;
+                var tMaxZ = (box.Max.Z - Position.Z) / Direction.Z;
+
+                if (tMinZ > tMaxZ)
+                {
+                    var temp = tMinZ;
+                    tMinZ = tMaxZ;
+                    tMaxZ = temp;
+                }
+
+                if ((tMin.HasValue && tMin > tMaxZ) || (tMax.HasValue && tMinZ > tMax))
+                    return null;
+
+                if (!tMin.HasValue || tMinZ > tMin) tMin = tMinZ;
+                if (!tMax.HasValue || tMaxZ < tMax) tMax = tMaxZ;
+            }
+
+            // having a positive tMin and a negative tMax means the ray is inside the box
+            // we expect the intesection distance to be 0 in that case
+            if ((tMin.HasValue && tMin < 0) && tMax > 0) return 0;
+
+            // a negative tMin means that the intersection point is behind the ray's origin
+            // we discard these as not hitting the AABB
+            if (tMin < 0) return null;
+
+            return tMin;
+        }
+
+
+        public void Intersects(ref BoundingBox box, out float? result)
+        {
+			result = Intersects(box);
+        }
+
+        /*
+        public float? Intersects(BoundingFrustum frustum)
+        {
+            if (frustum == null)
+			{
+				throw new ArgumentNullException("frustum");
+			}
+			
+			return frustum.Intersects(this);			
+        }
+        */
+
+        public float? Intersects(BoundingSphere sphere)
+        {
+            float? result;
+            Intersects(ref sphere, out result);
+            return result;
+        }
+
+        public float? Intersects(Plane plane)
+        {
+            float? result;
+            Intersects(ref plane, out result);
+            return result;
+        }
+
+        public void Intersects(ref Plane plane, out float? result)
+        {
+            var den = Vector3.Dot(Direction, plane.Normal);
+            if (Math.Abs(den) < 0.00001f)
+            {
+                result = null;
+                return;
+            }
+
+            result = (-plane.D - Vector3.Dot(plane.Normal, Position)) / den;
+
+            if (result < 0.0f)
+            {
+                if (result < -0.00001f)
+                {
+                    result = null;
+                    return;
+                }
+
+                result = 0.0f;
+            }
+        }
+
+        public void Intersects(ref BoundingSphere sphere, out float? result)
+        {
+            // Find the vector between where the ray starts the the sphere's centre
+            Vector3 difference = sphere.Center - this.Position;
+
+            float differenceLengthSquared = difference.LengthSquared();
+            float sphereRadiusSquared = sphere.Radius * sphere.Radius;
+
+            float distanceAlongRay;
+
+            // If the distance between the ray start and the sphere's centre is less than
+            // the radius of the sphere, it means we've intersected. N.B. checking the LengthSquared is faster.
+            if (differenceLengthSquared < sphereRadiusSquared)
+            {
+                result = 0.0f;
+                return;
+            }
+
+            Vector3.Dot(ref this.Direction, ref difference, out distanceAlongRay);
+            // If the ray is pointing away from the sphere then we don't ever intersect
+            if (distanceAlongRay < 0)
+            {
+                result = null;
+                return;
+            }
+
+            // Next we kinda use Pythagoras to check if we are within the bounds of the sphere
+            // if x = radius of sphere
+            // if y = distance between ray position and sphere centre
+            // if z = the distance we've travelled along the ray
+            // if x^2 + z^2 - y^2 < 0, we do not intersect
+            float dist = sphereRadiusSquared + distanceAlongRay * distanceAlongRay - differenceLengthSquared;
+
+            result = (dist < 0) ? null : distanceAlongRay - (float?)Math.Sqrt(dist);
+        }
+
+
+        public static bool operator !=(Ray a, Ray b)
+        {
+            return !a.Equals(b);
+        }
+
+
+        public static bool operator ==(Ray a, Ray b)
+        {
+            return a.Equals(b);
+        }
+
+        internal string DebugDisplayString
+        {
+            get
+            {
+                return string.Concat(
+                    "Pos( ", this.Position.DebugDisplayString, " )  \r\n",
+                    "Dir( ", this.Direction.DebugDisplayString, " )"
+                );
+            }
+        }
+
+        public override string ToString()
+        {
+            return "{{Position:" + Position.ToString() + " Direction:" + Direction.ToString() + "}}";
+        }
+
+        /// <summary>
+        /// Deconstruction method for <see cref="Ray"/>.
+        /// </summary>
+        /// <param name="position">Receives the start position of the ray.</param>
+        /// <param name="direction">Receives the direction of the ray.</param>
+        public void Deconstruct(out Vector3 position, out Vector3 direction)
+        {
+            position = Position;
+            direction = Direction;
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Rectangle.cs b/MonoGame.Framework/Rectangle.cs
new file mode 100644
index 00000000000..51c18e2d253
--- /dev/null
+++ b/MonoGame.Framework/Rectangle.cs
@@ -0,0 +1,539 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.Serialization;
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Describes a 2D-rectangle. 
+    /// </summary>
+    [DataContract]
+    [DebuggerDisplay("{DebugDisplayString,nq}")]
+    public struct Rectangle : IEquatable<Rectangle>
+    {
+        #region Private Fields
+
+        private static Rectangle emptyRectangle = new Rectangle();
+
+        #endregion
+
+        #region Public Fields
+
+        /// <summary>
+        /// The x coordinate of the top-left corner of this <see cref="Rectangle"/>.
+        /// </summary>
+        [DataMember]
+        public int X;
+
+        /// <summary>
+        /// The y coordinate of the top-left corner of this <see cref="Rectangle"/>.
+        /// </summary>
+        [DataMember]
+        public int Y;
+
+        /// <summary>
+        /// The width of this <see cref="Rectangle"/>.
+        /// </summary>
+        [DataMember]
+        public int Width;
+
+        /// <summary>
+        /// The height of this <see cref="Rectangle"/>.
+        /// </summary>
+        [DataMember]
+        public int Height;
+
+        #endregion
+
+        #region Public Properties
+
+        /// <summary>
+        /// Returns a <see cref="Rectangle"/> with X=0, Y=0, Width=0, Height=0.
+        /// </summary>
+        public static Rectangle Empty
+        {
+            get { return emptyRectangle; }
+        }
+
+        /// <summary>
+        /// Returns the x coordinate of the left edge of this <see cref="Rectangle"/>.
+        /// </summary>
+        public int Left
+        {
+            get { return this.X; }
+        }
+
+        /// <summary>
+        /// Returns the x coordinate of the right edge of this <see cref="Rectangle"/>.
+        /// </summary>
+        public int Right
+        {
+            get { return (this.X + this.Width); }
+        }
+
+        /// <summary>
+        /// Returns the y coordinate of the top edge of this <see cref="Rectangle"/>.
+        /// </summary>
+        public int Top
+        {
+            get { return this.Y; }
+        }
+
+        /// <summary>
+        /// Returns the y coordinate of the bottom edge of this <see cref="Rectangle"/>.
+        /// </summary>
+        public int Bottom
+        {
+            get { return (this.Y + this.Height); }
+        }
+
+        /// <summary>
+        /// Whether or not this <see cref="Rectangle"/> has a <see cref="Width"/> and
+        /// <see cref="Height"/> of 0, and a <see cref="Location"/> of (0, 0).
+        /// </summary>
+        public bool IsEmpty
+        {
+            get
+            {
+                return ((((this.Width == 0) && (this.Height == 0)) && (this.X == 0)) && (this.Y == 0));
+            }
+        }
+
+        /// <summary>
+        /// The top-left coordinates of this <see cref="Rectangle"/>.
+        /// </summary>
+        public Point Location
+        {
+            get
+            {
+                return new Point(this.X, this.Y);
+            }
+            set
+            {
+                X = value.X;
+                Y = value.Y;
+            }
+        }
+
+        /// <summary>
+        /// The width-height coordinates of this <see cref="Rectangle"/>.
+        /// </summary>
+        public Point Size
+        {
+            get
+            {
+                return new Point(this.Width,this.Height);
+            }
+            set
+            {
+                Width = value.X;
+                Height = value.Y;
+            }
+        }
+
+        /// <summary>
+        /// A <see cref="Point"/> located in the center of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <remarks>
+        /// If <see cref="Width"/> or <see cref="Height"/> is an odd number,
+        /// the center point will be rounded down.
+        /// </remarks>
+        public Point Center
+        {
+            get
+            {
+                return new Point(this.X + (this.Width / 2), this.Y + (this.Height / 2));
+            }
+        }
+
+        #endregion
+
+        #region Internal Properties
+
+        internal string DebugDisplayString
+        {
+            get
+            {
+                return string.Concat(
+                    this.X, "  ",
+                    this.Y, "  ",
+                    this.Width, "  ",
+                    this.Height
+                    );
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates a new instance of <see cref="Rectangle"/> struct, with the specified
+        /// position, width, and height.
+        /// </summary>
+        /// <param name="x">The x coordinate of the top-left corner of the created <see cref="Rectangle"/>.</param>
+        /// <param name="y">The y coordinate of the top-left corner of the created <see cref="Rectangle"/>.</param>
+        /// <param name="width">The width of the created <see cref="Rectangle"/>.</param>
+        /// <param name="height">The height of the created <see cref="Rectangle"/>.</param>
+        public Rectangle(int x, int y, int width, int height)
+        {
+            this.X = x;
+            this.Y = y;
+            this.Width = width;
+            this.Height = height;
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="Rectangle"/> struct, with the specified
+        /// location and size.
+        /// </summary>
+        /// <param name="location">The x and y coordinates of the top-left corner of the created <see cref="Rectangle"/>.</param>
+        /// <param name="size">The width and height of the created <see cref="Rectangle"/>.</param>
+        public Rectangle(Point location,Point size)
+        {
+            this.X = location.X;
+            this.Y = location.Y;
+            this.Width = size.X;
+            this.Height = size.Y;
+        }
+
+        #endregion
+
+        #region Operators
+
+        /// <summary>
+        /// Compares whether two <see cref="Rectangle"/> instances are equal.
+        /// </summary>
+        /// <param name="a"><see cref="Rectangle"/> instance on the left of the equal sign.</param>
+        /// <param name="b"><see cref="Rectangle"/> instance on the right of the equal sign.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Rectangle a, Rectangle b)
+        {
+            return ((a.X == b.X) && (a.Y == b.Y) && (a.Width == b.Width) && (a.Height == b.Height));
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="Rectangle"/> instances are not equal.
+        /// </summary>
+        /// <param name="a"><see cref="Rectangle"/> instance on the left of the not equal sign.</param>
+        /// <param name="b"><see cref="Rectangle"/> instance on the right of the not equal sign.</param>
+        /// <returns><c>true</c> if the instances are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Rectangle a, Rectangle b)
+        {
+            return !(a == b);
+        }
+
+        #endregion
+
+        #region Public Methods
+       
+        /// <summary>
+        /// Gets whether or not the provided coordinates lie within the bounds of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="x">The x coordinate of the point to check for containment.</param>
+        /// <param name="y">The y coordinate of the point to check for containment.</param>
+        /// <returns><c>true</c> if the provided coordinates lie inside this <see cref="Rectangle"/>; <c>false</c> otherwise.</returns>
+		public bool Contains(int x, int y)
+        {
+            return ((((this.X <= x) && (x < (this.X + this.Width))) && (this.Y <= y)) && (y < (this.Y + this.Height)));
+        }
+
+        /// <summary>
+        /// Gets whether or not the provided coordinates lie within the bounds of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="x">The x coordinate of the point to check for containment.</param>
+        /// <param name="y">The y coordinate of the point to check for containment.</param>
+        /// <returns><c>true</c> if the provided coordinates lie inside this <see cref="Rectangle"/>; <c>false</c> otherwise.</returns>
+        public bool Contains(float x, float y)
+        {
+            return ((((this.X <= x) && (x < (this.X + this.Width))) && (this.Y <= y)) && (y < (this.Y + this.Height)));
+        }
+		
+        /// <summary>
+        /// Gets whether or not the provided <see cref="Point"/> lies within the bounds of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="value">The coordinates to check for inclusion in this <see cref="Rectangle"/>.</param>
+        /// <returns><c>true</c> if the provided <see cref="Point"/> lies inside this <see cref="Rectangle"/>; <c>false</c> otherwise.</returns>
+        public bool Contains(Point value)
+        {
+            return ((((this.X <= value.X) && (value.X < (this.X + this.Width))) && (this.Y <= value.Y)) && (value.Y < (this.Y + this.Height)));
+        }
+
+        /// <summary>
+        /// Gets whether or not the provided <see cref="Point"/> lies within the bounds of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="value">The coordinates to check for inclusion in this <see cref="Rectangle"/>.</param>
+        /// <param name="result"><c>true</c> if the provided <see cref="Point"/> lies inside this <see cref="Rectangle"/>; <c>false</c> otherwise. As an output parameter.</param>
+        public void Contains(ref Point value, out bool result)
+        {
+            result = ((((this.X <= value.X) && (value.X < (this.X + this.Width))) && (this.Y <= value.Y)) && (value.Y < (this.Y + this.Height)));
+        }
+
+        /// <summary>
+        /// Gets whether or not the provided <see cref="Vector2"/> lies within the bounds of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="value">The coordinates to check for inclusion in this <see cref="Rectangle"/>.</param>
+        /// <returns><c>true</c> if the provided <see cref="Vector2"/> lies inside this <see cref="Rectangle"/>; <c>false</c> otherwise.</returns>
+        public bool Contains(Vector2 value)
+        {
+            return ((((this.X <= value.X) && (value.X < (this.X + this.Width))) && (this.Y <= value.Y)) && (value.Y < (this.Y + this.Height)));
+        }
+
+        /// <summary>
+        /// Gets whether or not the provided <see cref="Vector2"/> lies within the bounds of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="value">The coordinates to check for inclusion in this <see cref="Rectangle"/>.</param>
+        /// <param name="result"><c>true</c> if the provided <see cref="Vector2"/> lies inside this <see cref="Rectangle"/>; <c>false</c> otherwise. As an output parameter.</param>
+        public void Contains(ref Vector2 value, out bool result)
+        {
+            result = ((((this.X <= value.X) && (value.X < (this.X + this.Width))) && (this.Y <= value.Y)) && (value.Y < (this.Y + this.Height)));
+        }
+
+        /// <summary>
+        /// Gets whether or not the provided <see cref="Rectangle"/> lies within the bounds of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="value">The <see cref="Rectangle"/> to check for inclusion in this <see cref="Rectangle"/>.</param>
+        /// <returns><c>true</c> if the provided <see cref="Rectangle"/>'s bounds lie entirely inside this <see cref="Rectangle"/>; <c>false</c> otherwise.</returns>
+        public bool Contains(Rectangle value)
+        {
+            return ((((this.X <= value.X) && ((value.X + value.Width) <= (this.X + this.Width))) && (this.Y <= value.Y)) && ((value.Y + value.Height) <= (this.Y + this.Height)));
+        }
+
+        /// <summary>
+        /// Gets whether or not the provided <see cref="Rectangle"/> lies within the bounds of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="value">The <see cref="Rectangle"/> to check for inclusion in this <see cref="Rectangle"/>.</param>
+        /// <param name="result"><c>true</c> if the provided <see cref="Rectangle"/>'s bounds lie entirely inside this <see cref="Rectangle"/>; <c>false</c> otherwise. As an output parameter.</param>
+        public void Contains(ref Rectangle value,out bool result)
+        {
+            result = ((((this.X <= value.X) && ((value.X + value.Width) <= (this.X + this.Width))) && (this.Y <= value.Y)) && ((value.Y + value.Height) <= (this.Y + this.Height)));
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Object"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="Object"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is Rectangle) && this == ((Rectangle)obj);
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="other">The <see cref="Rectangle"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public bool Equals(Rectangle other)
+        {
+            return this == other;
+        }
+
+        /// <summary>
+        /// Gets the hash code of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <returns>Hash code of this <see cref="Rectangle"/>.</returns>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hash = 17;
+                hash = hash * 23 + X.GetHashCode();
+                hash = hash * 23 + Y.GetHashCode();
+                hash = hash * 23 + Width.GetHashCode();
+                hash = hash * 23 + Height.GetHashCode();
+                return hash;
+            }
+        }
+
+        /// <summary>
+        /// Adjusts the edges of this <see cref="Rectangle"/> by specified horizontal and vertical amounts. 
+        /// </summary>
+        /// <param name="horizontalAmount">Value to adjust the left and right edges.</param>
+        /// <param name="verticalAmount">Value to adjust the top and bottom edges.</param>
+        public void Inflate(int horizontalAmount, int verticalAmount)
+        {
+            X -= horizontalAmount;
+            Y -= verticalAmount;
+            Width += horizontalAmount * 2;
+            Height += verticalAmount * 2;
+        }
+
+        /// <summary>
+        /// Adjusts the edges of this <see cref="Rectangle"/> by specified horizontal and vertical amounts. 
+        /// </summary>
+        /// <param name="horizontalAmount">Value to adjust the left and right edges.</param>
+        /// <param name="verticalAmount">Value to adjust the top and bottom edges.</param>
+        public void Inflate(float horizontalAmount, float verticalAmount)
+        {
+            X -= (int)horizontalAmount;
+            Y -= (int)verticalAmount;
+            Width += (int)horizontalAmount * 2;
+            Height += (int)verticalAmount * 2;
+        }
+
+        /// <summary>
+        /// Gets whether or not the other <see cref="Rectangle"/> intersects with this rectangle.
+        /// </summary>
+        /// <param name="value">The other rectangle for testing.</param>
+        /// <returns><c>true</c> if other <see cref="Rectangle"/> intersects with this rectangle; <c>false</c> otherwise.</returns>
+        public bool Intersects(Rectangle value)
+        {
+            return value.Left < Right &&
+                   Left < value.Right &&
+                   value.Top < Bottom &&
+                   Top < value.Bottom;
+        }
+
+
+        /// <summary>
+        /// Gets whether or not the other <see cref="Rectangle"/> intersects with this rectangle.
+        /// </summary>
+        /// <param name="value">The other rectangle for testing.</param>
+        /// <param name="result"><c>true</c> if other <see cref="Rectangle"/> intersects with this rectangle; <c>false</c> otherwise. As an output parameter.</param>
+        public void Intersects(ref Rectangle value, out bool result)
+        {
+            result = value.Left < Right &&
+                     Left < value.Right &&
+                     value.Top < Bottom &&
+                     Top < value.Bottom;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Rectangle"/> that contains overlapping region of two other rectangles.
+        /// </summary>
+        /// <param name="value1">The first <see cref="Rectangle"/>.</param>
+        /// <param name="value2">The second <see cref="Rectangle"/>.</param>
+        /// <returns>Overlapping region of the two rectangles.</returns>
+        public static Rectangle Intersect(Rectangle value1, Rectangle value2)
+        {
+            Rectangle rectangle;
+            Intersect(ref value1, ref value2, out rectangle);
+            return rectangle;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Rectangle"/> that contains overlapping region of two other rectangles.
+        /// </summary>
+        /// <param name="value1">The first <see cref="Rectangle"/>.</param>
+        /// <param name="value2">The second <see cref="Rectangle"/>.</param>
+        /// <param name="result">Overlapping region of the two rectangles as an output parameter.</param>
+        public static void Intersect(ref Rectangle value1, ref Rectangle value2, out Rectangle result)
+        {
+            if (value1.Intersects(value2))
+            {
+                int right_side = Math.Min(value1.X + value1.Width, value2.X + value2.Width);
+                int left_side = Math.Max(value1.X, value2.X);
+                int top_side = Math.Max(value1.Y, value2.Y);
+                int bottom_side = Math.Min(value1.Y + value1.Height, value2.Y + value2.Height);
+                result = new Rectangle(left_side, top_side, right_side - left_side, bottom_side - top_side);
+            }
+            else
+            {
+                result = new Rectangle(0, 0, 0, 0);
+            }
+        }
+
+        /// <summary>
+        /// Changes the <see cref="Location"/> of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="offsetX">The x coordinate to add to this <see cref="Rectangle"/>.</param>
+        /// <param name="offsetY">The y coordinate to add to this <see cref="Rectangle"/>.</param>
+        public void Offset(int offsetX, int offsetY)
+        {
+            X += offsetX;
+            Y += offsetY;
+        }
+
+        /// <summary>
+        /// Changes the <see cref="Location"/> of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="offsetX">The x coordinate to add to this <see cref="Rectangle"/>.</param>
+        /// <param name="offsetY">The y coordinate to add to this <see cref="Rectangle"/>.</param>
+        public void Offset(float offsetX, float offsetY)
+        {
+            X += (int)offsetX;
+            Y += (int)offsetY;
+        }
+
+        /// <summary>
+        /// Changes the <see cref="Location"/> of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="amount">The x and y components to add to this <see cref="Rectangle"/>.</param>
+        public void Offset(Point amount)
+        {
+            X += amount.X;
+            Y += amount.Y;
+        }
+
+        /// <summary>
+        /// Changes the <see cref="Location"/> of this <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="amount">The x and y components to add to this <see cref="Rectangle"/>.</param>
+        public void Offset(Vector2 amount)
+        {
+            X += (int)amount.X;
+            Y += (int)amount.Y;
+        }
+
+        /// <summary>
+        /// Returns a <see cref="String"/> representation of this <see cref="Rectangle"/> in the format:
+        /// {X:[<see cref="X"/>] Y:[<see cref="Y"/>] Width:[<see cref="Width"/>] Height:[<see cref="Height"/>]}
+        /// </summary>
+        /// <returns><see cref="String"/> representation of this <see cref="Rectangle"/>.</returns>
+        public override string ToString()
+        {
+            return "{X:" + X + " Y:" + Y + " Width:" + Width + " Height:" + Height + "}";
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Rectangle"/> that completely contains two other rectangles.
+        /// </summary>
+        /// <param name="value1">The first <see cref="Rectangle"/>.</param>
+        /// <param name="value2">The second <see cref="Rectangle"/>.</param>
+        /// <returns>The union of the two rectangles.</returns>
+        public static Rectangle Union(Rectangle value1, Rectangle value2)
+        {
+            int x = Math.Min(value1.X, value2.X);
+            int y = Math.Min(value1.Y, value2.Y);
+            return new Rectangle(x, y,
+                                 Math.Max(value1.Right, value2.Right) - x,
+                                     Math.Max(value1.Bottom, value2.Bottom) - y);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Rectangle"/> that completely contains two other rectangles.
+        /// </summary>
+        /// <param name="value1">The first <see cref="Rectangle"/>.</param>
+        /// <param name="value2">The second <see cref="Rectangle"/>.</param>
+        /// <param name="result">The union of the two rectangles as an output parameter.</param>
+        public static void Union(ref Rectangle value1, ref Rectangle value2, out Rectangle result)
+        {
+            result.X = Math.Min(value1.X, value2.X);
+            result.Y = Math.Min(value1.Y, value2.Y);
+            result.Width = Math.Max(value1.Right, value2.Right) - result.X;
+            result.Height = Math.Max(value1.Bottom, value2.Bottom) - result.Y;
+        }
+
+        /// <summary>
+        /// Deconstruction method for <see cref="Rectangle"/>.
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <param name="width"></param>
+        /// <param name="height"></param>
+        public void Deconstruct(out int x, out int y, out int width, out int height)
+        {
+            x = X;
+            y = Y;
+            width = Width;
+            height = Height;
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Resources/Resource.Designer.cs b/MonoGame.Framework/Resources/Resource.Designer.cs
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/MonoGame.Framework/ReusableItemList.cs b/MonoGame.Framework/ReusableItemList.cs
new file mode 100644
index 00000000000..1a907d3c813
--- /dev/null
+++ b/MonoGame.Framework/ReusableItemList.cs
@@ -0,0 +1,170 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+
+namespace Microsoft.Xna.Framework
+{
+    internal class ReusableItemList<T> : ICollection<T>, IEnumerator<T>
+    {
+        private readonly List<T> _list = new List<T>();
+        private int _listTop = 0;
+        private int _iteratorIndex;
+
+        #region ICollection<T> Members
+
+        public void Add(T item)
+        {
+            if (_list.Count > _listTop)
+            {
+                _list[_listTop] = item;                
+            }
+            else
+            {
+                _list.Add(item);
+            }
+
+            _listTop++;
+        }
+		
+		public void Sort(IComparer<T> comparison)
+		{
+			_list.Sort(comparison);
+		}
+			
+		
+		public T GetNewItem()
+		{
+			if (_listTop < _list.Count)
+			{
+				return _list[_listTop++];
+			}
+			else
+			{
+				// Damm...Mono fails in this!
+				//return (T) Activator.CreateInstance(typeof(T));
+				return default(T);
+			}
+		}
+
+		public T this[int index]
+		{
+			get
+			{
+				if (index >= _listTop) 
+					throw new IndexOutOfRangeException();
+				return _list[index];
+			}
+			set
+			{
+				if (index >= _listTop) 
+					throw new IndexOutOfRangeException();
+				_list[index] = value;
+			}
+		}
+		
+        public void Clear()
+        {
+            _listTop = 0;
+        }
+
+        public void Reset()
+        {
+            Clear();
+            _list.Clear();
+        }
+
+        public bool Contains(T item)
+        {
+            return _list.Contains(item);
+        }
+
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            _list.CopyTo(array,arrayIndex);
+        }
+
+        public int Count
+        {
+            get 
+            {
+                return _listTop;
+            }
+        }
+
+        public bool IsReadOnly
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public bool Remove(T item)
+        {
+            throw new NotSupportedException();
+        }
+
+        #endregion
+
+        #region IEnumerable<T> Members
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            _iteratorIndex = -1;
+            return this;
+        }
+
+        #endregion
+
+        #region IEnumerable Members
+
+        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            _iteratorIndex = -1;
+            return this;
+        }
+
+        #endregion
+
+        #region IEnumerator<T> Members
+
+        public T Current
+        {
+            get
+            {
+                return _list[_iteratorIndex];
+            }
+        }
+
+        #endregion
+
+        #region IDisposable Members
+
+        public void Dispose()
+        {
+        }
+
+        #endregion
+
+        #region IEnumerator Members
+
+        object System.Collections.IEnumerator.Current
+        {
+            get
+            {
+                return _list[_iteratorIndex];
+            }
+        }
+
+        public bool MoveNext()
+        {
+            _iteratorIndex++;
+            return (_iteratorIndex < _listTop);
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/SDL/SDL2.cs b/MonoGame.Framework/SDL/SDL2.cs
new file mode 100644
index 00000000000..743b4c05e29
--- /dev/null
+++ b/MonoGame.Framework/SDL/SDL2.cs
@@ -0,0 +1,1107 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using MonoGame.Utilities;
+
+internal static class Sdl
+{
+    public static IntPtr NativeLibrary = GetNativeLibrary();
+
+    private static IntPtr GetNativeLibrary()
+    {
+        var ret = IntPtr.Zero;
+
+        // Load bundled library
+        var assemblyLocation = Path.GetDirectoryName(typeof(Sdl).Assembly.Location);
+        if (CurrentPlatform.OS == OS.Windows && Environment.Is64BitProcess)
+            ret = FuncLoader.LoadLibrary(Path.Combine(assemblyLocation, "x64/SDL2.dll"));
+        else if (CurrentPlatform.OS == OS.Windows && !Environment.Is64BitProcess)
+            ret = FuncLoader.LoadLibrary(Path.Combine(assemblyLocation, "x86/SDL2.dll"));
+        else if (CurrentPlatform.OS == OS.Linux && Environment.Is64BitProcess)
+            ret = FuncLoader.LoadLibrary(Path.Combine(assemblyLocation, "x64/libSDL2-2.0.so.0"));
+        else if (CurrentPlatform.OS == OS.Linux && !Environment.Is64BitProcess)
+            ret = FuncLoader.LoadLibrary(Path.Combine(assemblyLocation, "x86/libSDL2-2.0.so.0"));
+        else if (CurrentPlatform.OS == OS.MacOSX)
+            ret = FuncLoader.LoadLibrary(Path.Combine(assemblyLocation, "libSDL2-2.0.0.dylib"));
+
+        // Load system library
+        if (ret == IntPtr.Zero)
+        {
+            if (CurrentPlatform.OS == OS.Windows)
+                ret = FuncLoader.LoadLibrary("SDL2.dll");
+            else if (CurrentPlatform.OS == OS.Linux)
+                ret = FuncLoader.LoadLibrary("libSDL2-2.0.so.0");
+            else
+                ret = FuncLoader.LoadLibrary("libSDL2-2.0.0.dylib");
+        }
+
+        // Welp, all failed, PANIC!!!
+        if (ret == IntPtr.Zero)
+            throw new Exception("Failed to load SDL library.");
+
+        return ret;
+    }
+
+    public static int Major;
+    public static int Minor;
+    public static int Patch;
+
+    [Flags]
+    public enum InitFlags
+    {
+        Video = 0x00000020,
+        Joystick = 0x00000200,
+        Haptic = 0x00001000,
+        GameController = 0x00002000,
+    }
+
+    public enum EventType : uint
+    {
+        First = 0,
+
+        Quit = 0x100,
+
+        WindowEvent = 0x200,
+        SysWM = 0x201,
+
+        KeyDown = 0x300,
+        KeyUp = 0x301,
+        TextEditing = 0x302,
+        TextInput = 0x303,
+
+        MouseMotion = 0x400,
+        MouseButtonDown = 0x401,
+        MouseButtonup = 0x402,
+        MouseWheel = 0x403,
+
+        JoyAxisMotion = 0x600,
+        JoyBallMotion = 0x601,
+        JoyHatMotion = 0x602,
+        JoyButtonDown = 0x603,
+        JoyButtonUp = 0x604,
+        JoyDeviceAdded = 0x605,
+        JoyDeviceRemoved = 0x606,
+
+        ControllerAxisMotion = 0x650,
+        ControllerButtonDown = 0x651,
+        ControllerButtonUp = 0x652,
+        ControllerDeviceAdded = 0x653,
+        ControllerDeviceRemoved = 0x654,
+        ControllerDeviceRemapped = 0x654,
+
+        FingerDown = 0x700,
+        FingerUp = 0x701,
+        FingerMotion = 0x702,
+
+        DollarGesture = 0x800,
+        DollarRecord = 0x801,
+        MultiGesture = 0x802,
+
+        ClipboardUpdate = 0x900,
+
+        DropFile = 0x1000,
+
+        AudioDeviceAdded = 0x1100,
+        AudioDeviceRemoved = 0x1101,
+
+        RenderTargetsReset = 0x2000,
+        RenderDeviceReset = 0x2001,
+
+        UserEvent = 0x8000,
+
+        Last = 0xFFFF
+    }
+
+    public enum EventAction
+    {
+        AddEvent = 0x0,
+        PeekEvent = 0x1,
+        GetEvent = 0x2,
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size = 56)]
+    public struct Event
+    {
+        [FieldOffset(0)]
+        public EventType Type;
+        [FieldOffset(0)]
+        public Window.Event Window;
+        [FieldOffset(0)]
+        public Keyboard.Event Key;
+        [FieldOffset(0)]
+        public Mouse.MotionEvent Motion;
+        [FieldOffset(0)]
+        public Keyboard.TextEditingEvent Edit;
+        [FieldOffset(0)]
+        public Keyboard.TextInputEvent Text;
+        [FieldOffset(0)]
+        public Mouse.WheelEvent Wheel;
+        [FieldOffset(0)]
+        public Joystick.DeviceEvent JoystickDevice;
+        [FieldOffset(0)]
+        public GameController.DeviceEvent ControllerDevice;
+    }
+
+    public struct Rectangle
+    {
+        public int X;
+        public int Y;
+        public int Width;
+        public int Height;
+    }
+
+    public struct Version
+    {
+        public byte Major;
+        public byte Minor;
+        public byte Patch;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int d_sdl_init(int flags);
+    public static d_sdl_init SDL_Init = FuncLoader.LoadFunction<d_sdl_init>(NativeLibrary, "SDL_Init");
+
+    public static void Init(int flags)
+    {
+        GetError(SDL_Init(flags));
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void d_sdl_disablescreensaver();
+    public static d_sdl_disablescreensaver DisableScreenSaver = FuncLoader.LoadFunction<d_sdl_disablescreensaver>(NativeLibrary, "SDL_DisableScreenSaver");
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void d_sdl_getversion(out Version version);
+    public static d_sdl_getversion GetVersion = FuncLoader.LoadFunction<d_sdl_getversion>(NativeLibrary, "SDL_GetVersion");
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int d_sdl_pollevent([Out] out Event _event);
+    public static d_sdl_pollevent PollEvent = FuncLoader.LoadFunction<d_sdl_pollevent>(NativeLibrary, "SDL_PollEvent");
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int d_sdl_pumpevents();
+    public static d_sdl_pumpevents PumpEvents = FuncLoader.LoadFunction<d_sdl_pumpevents>(NativeLibrary, "SDL_PumpEvents");
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate IntPtr d_sdl_creatergbsurfacefrom(IntPtr pixels, int width, int height, int depth, int pitch, uint rMask, uint gMask, uint bMask, uint aMask);
+    private static d_sdl_creatergbsurfacefrom SDL_CreateRGBSurfaceFrom = FuncLoader.LoadFunction<d_sdl_creatergbsurfacefrom>(NativeLibrary, "SDL_CreateRGBSurfaceFrom");
+
+    public static IntPtr CreateRGBSurfaceFrom(byte[] pixels, int width, int height, int depth, int pitch, uint rMask, uint gMask, uint bMask, uint aMask)
+    {
+        var handle = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+        try
+        {
+            return SDL_CreateRGBSurfaceFrom(handle.AddrOfPinnedObject(), width, height, depth, pitch, rMask, gMask, bMask, aMask);
+        }
+        finally
+        {
+            handle.Free();
+        }
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void d_sdl_freesurface(IntPtr surface);
+    public static d_sdl_freesurface FreeSurface = FuncLoader.LoadFunction<d_sdl_freesurface>(NativeLibrary, "SDL_FreeSurface");
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate IntPtr d_sdl_geterror();
+    private static d_sdl_geterror SDL_GetError = FuncLoader.LoadFunction<d_sdl_geterror>(NativeLibrary, "SDL_GetError");
+
+    public static string GetError()
+    {
+        return InteropHelpers.Utf8ToString(SDL_GetError());
+    }
+
+    public static int GetError(int value)
+    {
+        if (value < 0)
+            Debug.WriteLine(GetError());
+
+        return value;
+    }
+
+    public static IntPtr GetError(IntPtr pointer)
+    {
+        if (pointer == IntPtr.Zero)
+            Debug.WriteLine(GetError());
+
+        return pointer;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void d_sdl_clearerror();
+    public static d_sdl_clearerror ClearError = FuncLoader.LoadFunction<d_sdl_clearerror>(NativeLibrary, "SDL_ClearError");
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate IntPtr d_sdl_gethint(string name);
+    public static d_sdl_gethint SDL_GetHint = FuncLoader.LoadFunction<d_sdl_gethint>(NativeLibrary, "SDL_GetHint");
+
+    public static string GetHint(string name)
+    {
+        return InteropHelpers.Utf8ToString(SDL_GetHint(name));
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate IntPtr d_sdl_loadbmp_rw(IntPtr src, int freesrc);
+    private static d_sdl_loadbmp_rw SDL_LoadBMP_RW = FuncLoader.LoadFunction<d_sdl_loadbmp_rw>(NativeLibrary, "SDL_LoadBMP_RW");
+
+    public static IntPtr LoadBMP_RW(IntPtr src, int freesrc)
+    {
+        return GetError(SDL_LoadBMP_RW(src, freesrc));
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate void d_sdl_quit();
+    public static d_sdl_quit Quit = FuncLoader.LoadFunction<d_sdl_quit>(NativeLibrary, "SDL_Quit");
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    private delegate IntPtr d_sdl_rwfrommem(byte[] mem, int size);
+    private static d_sdl_rwfrommem SDL_RWFromMem = FuncLoader.LoadFunction<d_sdl_rwfrommem>(NativeLibrary, "SDL_RWFromMem");
+
+    public static IntPtr RwFromMem(byte[] mem, int size)
+    {
+        return GetError(SDL_RWFromMem(mem, size));
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate int d_sdl_sethint(string name, string value);
+    public static d_sdl_sethint SetHint = FuncLoader.LoadFunction<d_sdl_sethint>(NativeLibrary, "SDL_SetHint");
+
+    public static class Window
+    {
+        public const int PosUndefined = 0x1FFF0000;
+        public const int PosCentered = 0x2FFF0000;
+
+        public enum EventId : byte
+        {
+            None,
+            Shown,
+            Hidden,
+            Exposed,
+            Moved,
+            Resized,
+            SizeChanged,
+            Minimized,
+            Maximized,
+            Restored,
+            Enter,
+            Leave,
+            FocusGained,
+            FocusLost,
+            Close,
+        }
+
+        public static class State
+        {
+            public const int Fullscreen = 0x00000001;
+            public const int OpenGL = 0x00000002;
+            public const int Shown = 0x00000004;
+            public const int Hidden = 0x00000008;
+            public const int Borderless = 0x00000010;
+            public const int Resizable = 0x00000020;
+            public const int Minimized = 0x00000040;
+            public const int Maximized = 0x00000080;
+            public const int Grabbed = 0x00000100;
+            public const int InputFocus = 0x00000200;
+            public const int MouseFocus = 0x00000400;
+            public const int FullscreenDesktop = 0x00001001;
+            public const int Foreign = 0x00000800;
+            public const int AllowHighDPI = 0x00002000;
+            public const int MouseCapture = 0x00004000;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct Event
+        {
+            public EventType Type;
+            public uint TimeStamp;
+            public uint WindowID;
+            public EventId EventID;
+            private byte padding1;
+            private byte padding2;
+            private byte padding3;
+            public int Data1;
+            public int Data2;
+        }
+
+        public enum SysWMType
+        {
+            Unknow,
+            Windows,
+            X11,
+            Directfb,
+            Cocoa,
+            UiKit,
+            Wayland,
+            Mir,
+            WinRt,
+            Android
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct SDL_SysWMinfo
+        {
+            public Version version;
+            public SysWMType subsystem;
+            public IntPtr window;
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_createwindow(string title, int x, int y, int w, int h, int flags);
+        private static d_sdl_createwindow SDL_CreateWindow = FuncLoader.LoadFunction<d_sdl_createwindow>(NativeLibrary, "SDL_CreateWindow");
+
+        public static IntPtr Create(string title, int x, int y, int w, int h, int flags)
+        {
+            return GetError(SDL_CreateWindow(title, x, y, w, h, flags));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_destroywindow(IntPtr window);
+        public static d_sdl_destroywindow Destroy = FuncLoader.LoadFunction<d_sdl_destroywindow>(NativeLibrary, "SDL_DestroyWindow");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate uint d_sdl_getwindowid(IntPtr window);
+        public static d_sdl_getwindowid GetWindowId = FuncLoader.LoadFunction<d_sdl_getwindowid>(NativeLibrary, "SDL_GetWindowID");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_getwindowdisplayindex(IntPtr window);
+        private static d_sdl_getwindowdisplayindex SDL_GetWindowDisplayIndex = FuncLoader.LoadFunction<d_sdl_getwindowdisplayindex>(NativeLibrary, "SDL_GetWindowDisplayIndex");
+
+        public static int GetDisplayIndex(IntPtr window)
+        {
+            return GetError(SDL_GetWindowDisplayIndex(window));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate int d_sdl_getwindowflags(IntPtr window);
+        public static d_sdl_getwindowflags GetWindowFlags = FuncLoader.LoadFunction<d_sdl_getwindowflags>(NativeLibrary, "SDL_GetWindowFlags");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_setwindowicon(IntPtr window, IntPtr icon);
+        public static d_sdl_setwindowicon SetIcon = FuncLoader.LoadFunction<d_sdl_setwindowicon>(NativeLibrary, "SDL_SetWindowIcon");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_getwindowposition(IntPtr window, out int x, out int y);
+        public static d_sdl_getwindowposition GetPosition = FuncLoader.LoadFunction<d_sdl_getwindowposition>(NativeLibrary, "SDL_GetWindowPosition");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_getwindowsize(IntPtr window, out int w, out int h);
+        public static d_sdl_getwindowsize GetSize = FuncLoader.LoadFunction<d_sdl_getwindowsize>(NativeLibrary, "SDL_GetWindowSize");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_setwindowbordered(IntPtr window, int bordered);
+        public static d_sdl_setwindowbordered SetBordered = FuncLoader.LoadFunction<d_sdl_setwindowbordered>(NativeLibrary, "SDL_SetWindowBordered");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_setwindowfullscreen(IntPtr window, int flags);
+        private static d_sdl_setwindowfullscreen SDL_SetWindowFullscreen = FuncLoader.LoadFunction<d_sdl_setwindowfullscreen>(NativeLibrary, "SDL_SetWindowFullscreen");
+
+        public static void SetFullscreen(IntPtr window, int flags)
+        {
+            GetError(SDL_SetWindowFullscreen(window, flags));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_setwindowposition(IntPtr window, int x, int y);
+        public static d_sdl_setwindowposition SetPosition = FuncLoader.LoadFunction<d_sdl_setwindowposition>(NativeLibrary, "SDL_SetWindowPosition");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_setwindowresizable(IntPtr window, bool resizable);
+        public static d_sdl_setwindowresizable SetResizable = FuncLoader.LoadFunction<d_sdl_setwindowresizable>(NativeLibrary, "SDL_SetWindowResizable");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_setwindowsize(IntPtr window, int w, int h);
+        public static d_sdl_setwindowsize SetSize = FuncLoader.LoadFunction<d_sdl_setwindowsize>(NativeLibrary, "SDL_SetWindowSize");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate void d_sdl_setwindowtitle(IntPtr window, ref byte value);
+        private static d_sdl_setwindowtitle SDL_SetWindowTitle = FuncLoader.LoadFunction<d_sdl_setwindowtitle>(NativeLibrary, "SDL_SetWindowTitle");
+
+        public static void SetTitle(IntPtr handle, string title)
+        {
+            var bytes = Encoding.UTF8.GetBytes(title);
+            SDL_SetWindowTitle(handle, ref bytes[0]);
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_showwindow(IntPtr window);
+        public static d_sdl_showwindow Show = FuncLoader.LoadFunction<d_sdl_showwindow>(NativeLibrary, "SDL_ShowWindow");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate bool d_sdl_getwindowwminfo(IntPtr window, ref SDL_SysWMinfo sysWMinfo);
+        public static d_sdl_getwindowwminfo GetWindowWMInfo = FuncLoader.LoadFunction<d_sdl_getwindowwminfo>(NativeLibrary, "SDL_GetWindowWMInfo");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate int d_sdl_getwindowborderssize(IntPtr window, out int top, out int left, out int right, out int bottom);
+        public static d_sdl_getwindowborderssize GetBorderSize = FuncLoader.LoadFunction<d_sdl_getwindowborderssize>(NativeLibrary, "SDL_GetWindowBordersSize");
+    }
+
+    public static class Display
+    {
+        public struct Mode
+        {
+            public uint Format;
+            public int Width;
+            public int Height;
+            public int RefreshRate;
+            public IntPtr DriverData;
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_getdisplaybounds(int displayIndex, out Rectangle rect);
+        private static d_sdl_getdisplaybounds SDL_GetDisplayBounds = FuncLoader.LoadFunction<d_sdl_getdisplaybounds>(NativeLibrary, "SDL_GetDisplayBounds");
+
+        public static void GetBounds(int displayIndex, out Rectangle rect)
+        {
+            GetError(SDL_GetDisplayBounds(displayIndex, out rect));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_getcurrentdisplaymode(int displayIndex, out Mode mode);
+        private static d_sdl_getcurrentdisplaymode SDL_GetCurrentDisplayMode = FuncLoader.LoadFunction<d_sdl_getcurrentdisplaymode>(NativeLibrary, "SDL_GetCurrentDisplayMode");
+
+        public static void GetCurrentDisplayMode(int displayIndex, out Mode mode)
+        {
+            GetError(SDL_GetCurrentDisplayMode(displayIndex, out mode));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_getdisplaymode(int displayIndex, int modeIndex, out Mode mode);
+        private static d_sdl_getdisplaymode SDL_GetDisplayMode = FuncLoader.LoadFunction<d_sdl_getdisplaymode>(NativeLibrary, "SDL_GetDisplayMode");
+
+        public static void GetDisplayMode(int displayIndex, int modeIndex, out Mode mode)
+        {
+            GetError(SDL_GetDisplayMode(displayIndex, modeIndex, out mode));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_getclosestdisplaymode(int displayIndex, Mode mode, out Mode closest);
+        private static d_sdl_getclosestdisplaymode SDL_GetClosestDisplayMode = FuncLoader.LoadFunction<d_sdl_getclosestdisplaymode>(NativeLibrary, "SDL_GetClosestDisplayMode");
+
+        public static void GetClosestDisplayMode(int displayIndex, Mode mode, out Mode closest)
+        {
+            GetError(SDL_GetClosestDisplayMode(displayIndex, mode, out closest));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_getdisplayname(int index);
+        private static d_sdl_getdisplayname SDL_GetDisplayName = FuncLoader.LoadFunction<d_sdl_getdisplayname>(NativeLibrary, "SDL_GetDisplayName");
+
+        public static string GetDisplayName(int index)
+        {
+            return InteropHelpers.Utf8ToString(GetError(SDL_GetDisplayName(index)));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_getnumdisplaymodes(int displayIndex);
+        private static d_sdl_getnumdisplaymodes SDL_GetNumDisplayModes = FuncLoader.LoadFunction<d_sdl_getnumdisplaymodes>(NativeLibrary, "SDL_GetNumDisplayModes");
+
+        public static int GetNumDisplayModes(int displayIndex)
+        {
+            return GetError(SDL_GetNumDisplayModes(displayIndex));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_getnumvideodisplays();
+        private static d_sdl_getnumvideodisplays SDL_GetNumVideoDisplays = FuncLoader.LoadFunction<d_sdl_getnumvideodisplays>(NativeLibrary, "SDL_GetNumVideoDisplays");
+
+        public static int GetNumVideoDisplays()
+        {
+            return GetError(SDL_GetNumVideoDisplays());
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_getwindowdisplayindex(IntPtr window);
+        private static d_sdl_getwindowdisplayindex SDL_GetWindowDisplayIndex = FuncLoader.LoadFunction<d_sdl_getwindowdisplayindex>(NativeLibrary, "SDL_GetWindowDisplayIndex");
+
+        public static int GetWindowDisplayIndex(IntPtr window)
+        {
+            return GetError(SDL_GetWindowDisplayIndex(window));
+        }
+    }
+
+    public static class GL
+    {
+        public enum Attribute
+        {
+            RedSize,
+            GreenSize,
+            BlueSize,
+            AlphaSize,
+            BufferSize,
+            DoubleBuffer,
+            DepthSize,
+            StencilSize,
+            AccumRedSize,
+            AccumGreenSize,
+            AccumBlueSize,
+            AccumAlphaSize,
+            Stereo,
+            MultiSampleBuffers,
+            MultiSampleSamples,
+            AcceleratedVisual,
+            RetainedBacking,
+            ContextMajorVersion,
+            ContextMinorVersion,
+            ContextEgl,
+            ContextFlags,
+            ContextProfileMAsl,
+            ShareWithCurrentContext,
+            FramebufferSRGBCapable,
+            ContextReleaseBehaviour,
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_gl_createcontext(IntPtr window);
+        private static d_sdl_gl_createcontext SDL_GL_CreateContext = FuncLoader.LoadFunction<d_sdl_gl_createcontext>(NativeLibrary, "SDL_GL_CreateContext");
+
+        public static IntPtr CreateContext(IntPtr window)
+        {
+            return GetError(SDL_GL_CreateContext(window));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_gl_deletecontext(IntPtr context);
+        public static d_sdl_gl_deletecontext DeleteContext = FuncLoader.LoadFunction<d_sdl_gl_deletecontext>(NativeLibrary, "SDL_GL_DeleteContext");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_gl_getcurrentcontext();
+        private static d_sdl_gl_getcurrentcontext SDL_GL_GetCurrentContext = FuncLoader.LoadFunction<d_sdl_gl_getcurrentcontext>(NativeLibrary, "SDL_GL_GetCurrentContext");
+
+        public static IntPtr GetCurrentContext()
+        {
+            return GetError(SDL_GL_GetCurrentContext());
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate IntPtr d_sdl_gl_getprocaddress(string proc);
+        public static d_sdl_gl_getprocaddress GetProcAddress = FuncLoader.LoadFunction<d_sdl_gl_getprocaddress>(NativeLibrary, "SDL_GL_GetProcAddress");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate int d_sdl_gl_getswapinterval();
+        public static d_sdl_gl_getswapinterval GetSwapInterval = FuncLoader.LoadFunction<d_sdl_gl_getswapinterval>(NativeLibrary, "SDL_GL_GetSwapInterval");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate int d_sdl_gl_makecurrent(IntPtr window, IntPtr context);
+        public static d_sdl_gl_makecurrent MakeCurrent = FuncLoader.LoadFunction<d_sdl_gl_makecurrent>(NativeLibrary, "SDL_GL_MakeCurrent");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_gl_setattribute(Attribute attr, int value);
+        private static d_sdl_gl_setattribute SDL_GL_SetAttribute = FuncLoader.LoadFunction<d_sdl_gl_setattribute>(NativeLibrary, "SDL_GL_SetAttribute");
+
+        public static int SetAttribute(Attribute attr, int value)
+        {
+            return GetError(SDL_GL_SetAttribute(attr, value));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate int d_sdl_gl_setswapinterval(int interval);
+        public static d_sdl_gl_setswapinterval SetSwapInterval = FuncLoader.LoadFunction<d_sdl_gl_setswapinterval>(NativeLibrary, "SDL_GL_SetSwapInterval");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_gl_swapwindow(IntPtr window);
+        public static d_sdl_gl_swapwindow SwapWindow = FuncLoader.LoadFunction<d_sdl_gl_swapwindow>(NativeLibrary, "SDL_GL_SwapWindow");
+    }
+
+    public static class Mouse
+    {
+        [Flags]
+        public enum Button
+        {
+            Left = 1 << 0,
+            Middle = 1 << 1,
+            Right = 1 << 2,
+            X1Mask = 1 << 3,
+            X2Mask = 1 << 4
+        }
+
+        public enum SystemCursor
+        {
+            Arrow,
+            IBeam,
+            Wait,
+            Crosshair,
+            WaitArrow,
+            SizeNWSE,
+            SizeNESW,
+            SizeWE,
+            SizeNS,
+            SizeAll,
+            No,
+            Hand
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct MotionEvent
+        {
+            public EventType Type;
+            public uint Timestamp;
+            public uint WindowID;
+            public uint Which;
+            public byte State;
+            private byte _padding1;
+            private byte _padding2;
+            private byte _padding3;
+            public int X;
+            public int Y;
+            public int Xrel;
+            public int Yrel;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct WheelEvent
+        {
+            public EventType Type;
+            public uint TimeStamp;
+            public uint WindowId;
+            public uint Which;
+            public int X;
+            public int Y;
+            public uint Direction;
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_createcolorcursor(IntPtr surface, int x, int y);
+        private static d_sdl_createcolorcursor SDL_CreateColorCursor = FuncLoader.LoadFunction<d_sdl_createcolorcursor>(NativeLibrary, "SDL_CreateColorCursor");
+
+        public static IntPtr CreateColorCursor(IntPtr surface, int x, int y)
+        {
+            return GetError(SDL_CreateColorCursor(surface, x, y));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_createsystemcursor(SystemCursor id);
+        private static d_sdl_createsystemcursor SDL_CreateSystemCursor = FuncLoader.LoadFunction<d_sdl_createsystemcursor>(NativeLibrary, "SDL_CreateSystemCursor");
+
+        public static IntPtr CreateSystemCursor(SystemCursor id)
+        {
+            return GetError(SDL_CreateSystemCursor(id));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_freecursor(IntPtr cursor);
+        public static d_sdl_freecursor FreeCursor = FuncLoader.LoadFunction<d_sdl_freecursor>(NativeLibrary, "SDL_FreeCursor");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate Button d_sdl_getglobalmousestate(out int x, out int y);
+        public static d_sdl_getglobalmousestate GetGlobalState = FuncLoader.LoadFunction<d_sdl_getglobalmousestate>(NativeLibrary, "SDL_GetGlobalMouseState");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate Button d_sdl_getmousestate(out int x, out int y);
+        public static d_sdl_getmousestate GetState = FuncLoader.LoadFunction<d_sdl_getmousestate>(NativeLibrary, "SDL_GetMouseState");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_setcursor(IntPtr cursor);
+        public static d_sdl_setcursor SetCursor = FuncLoader.LoadFunction<d_sdl_setcursor>(NativeLibrary, "SDL_SetCursor");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate int d_sdl_showcursor(int toggle);
+        public static d_sdl_showcursor ShowCursor = FuncLoader.LoadFunction<d_sdl_showcursor>(NativeLibrary, "SDL_ShowCursor");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_warpmouseinwindow(IntPtr window, int x, int y);
+        public static d_sdl_warpmouseinwindow WarpInWindow = FuncLoader.LoadFunction<d_sdl_warpmouseinwindow>(NativeLibrary, "SDL_WarpMouseInWindow");
+    }
+
+    public static class Keyboard
+    {
+        public struct Keysym
+        {
+            public int Scancode;
+            public int Sym;
+            public Keymod Mod;
+            public uint Unicode;
+        }
+
+        [Flags]
+        public enum Keymod : ushort
+        {
+            None = 0x0000,
+            LeftShift = 0x0001,
+            RightShift = 0x0002,
+            LeftCtrl = 0x0040,
+            RightCtrl = 0x0080,
+            LeftAlt = 0x0100,
+            RightAlt = 0x0200,
+            LeftGui = 0x0400,
+            RightGui = 0x0800,
+            NumLock = 0x1000,
+            CapsLock = 0x2000,
+            AltGr = 0x4000,
+            Reserved = 0x8000,
+            Ctrl = (LeftCtrl | RightCtrl),
+            Shift = (LeftShift | RightShift),
+            Alt = (LeftAlt | RightAlt),
+            Gui = (LeftGui | RightGui)
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct Event
+        {
+            public EventType Type;
+            public uint TimeStamp;
+            public uint WindowId;
+            public byte State;
+            public byte Repeat;
+            private byte padding2;
+            private byte padding3;
+            public Keysym Keysym;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public unsafe struct TextEditingEvent
+        {
+            public EventType Type;
+            public uint Timestamp;
+            public uint WindowId;
+            public fixed byte Text[32];
+            public int Start;
+            public int Length;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public unsafe struct TextInputEvent
+        {
+            public EventType Type;
+            public uint Timestamp;
+            public uint WindowId;
+            public fixed byte Text[32];
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate Keymod d_sdl_getmodstate();
+        public static d_sdl_getmodstate GetModState = FuncLoader.LoadFunction<d_sdl_getmodstate>(NativeLibrary, "SDL_GetModState");
+    }
+
+    public static class Joystick
+    {
+        [Flags]
+        public enum Hat : byte
+        {
+            Centered = 0,
+            Up = 1 << 0,
+            Right = 1 << 1,
+            Down = 1 << 2,
+            Left = 1 << 3
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DeviceEvent
+        {
+            public EventType Type;
+            public uint TimeStamp;
+            public int Which;
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_joystickclose(IntPtr joystick);
+        public static d_sdl_joystickclose Close = FuncLoader.LoadFunction<d_sdl_joystickclose>(NativeLibrary, "SDL_JoystickClose");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_joystickfrominstanceid(int joyid);
+        private static d_sdl_joystickfrominstanceid SDL_JoystickFromInstanceID = FuncLoader.LoadFunction<d_sdl_joystickfrominstanceid>(NativeLibrary, "SDL_JoystickFromInstanceID");
+
+        public static IntPtr FromInstanceID(int joyid)
+        {
+            return GetError(SDL_JoystickFromInstanceID(joyid));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate short d_sdl_joystickgetaxis(IntPtr joystick, int axis);
+        public static d_sdl_joystickgetaxis GetAxis = FuncLoader.LoadFunction<d_sdl_joystickgetaxis>(NativeLibrary, "SDL_JoystickGetAxis");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate byte d_sdl_joystickgetbutton(IntPtr joystick, int button);
+        public static d_sdl_joystickgetbutton GetButton = FuncLoader.LoadFunction<d_sdl_joystickgetbutton>(NativeLibrary, "SDL_JoystickGetButton");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate Guid d_sdl_joystickgetguid(IntPtr joystick);
+        public static d_sdl_joystickgetguid GetGUID = FuncLoader.LoadFunction<d_sdl_joystickgetguid>(NativeLibrary, "SDL_JoystickGetGUID");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate Hat d_sdl_joystickgethat(IntPtr joystick, int hat);
+        public static d_sdl_joystickgethat GetHat = FuncLoader.LoadFunction<d_sdl_joystickgethat>(NativeLibrary, "SDL_JoystickGetHat");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate int d_sdl_joystickinstanceid(IntPtr joystick);
+        public static d_sdl_joystickinstanceid InstanceID = FuncLoader.LoadFunction<d_sdl_joystickinstanceid>(NativeLibrary, "SDL_JoystickInstanceID");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_joystickopen(int deviceIndex);
+        private static d_sdl_joystickopen SDL_JoystickOpen = FuncLoader.LoadFunction<d_sdl_joystickopen>(NativeLibrary, "SDL_JoystickOpen");
+
+        public static IntPtr Open(int deviceIndex)
+        {
+            return GetError(SDL_JoystickOpen(deviceIndex));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_joysticknumaxes(IntPtr joystick);
+        private static d_sdl_joysticknumaxes SDL_JoystickNumAxes = FuncLoader.LoadFunction<d_sdl_joysticknumaxes>(NativeLibrary, "SDL_JoystickNumAxes");
+
+        public static int NumAxes(IntPtr joystick)
+        {
+            return GetError(SDL_JoystickNumAxes(joystick));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_joysticknumbuttons(IntPtr joystick);
+        private static d_sdl_joysticknumbuttons SDL_JoystickNumButtons = FuncLoader.LoadFunction<d_sdl_joysticknumbuttons>(NativeLibrary, "SDL_JoystickNumButtons");
+
+        public static int NumButtons(IntPtr joystick)
+        {
+            return GetError(SDL_JoystickNumButtons(joystick));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_joysticknumhats(IntPtr joystick);
+        private static d_sdl_joysticknumhats SDL_JoystickNumHats = FuncLoader.LoadFunction<d_sdl_joysticknumhats>(NativeLibrary, "SDL_JoystickNumHats");
+
+        public static int NumHats(IntPtr joystick)
+        {
+            return GetError(SDL_JoystickNumHats(joystick));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_numjoysticks();
+        private static d_sdl_numjoysticks SDL_NumJoysticks = FuncLoader.LoadFunction<d_sdl_numjoysticks>(NativeLibrary, "SDL_NumJoysticks");
+
+        public static int NumJoysticks()
+        {
+            return GetError(SDL_NumJoysticks());
+        }
+    }
+
+    public static class GameController
+    {
+        public enum Axis
+        {
+            Invalid = -1,
+            LeftX,
+            LeftY,
+            RightX,
+            RightY,
+            TriggerLeft,
+            TriggerRight,
+            Max,
+        }
+
+        public enum Button
+        {
+            Invalid = -1,
+            A,
+            B,
+            X,
+            Y,
+            Back,
+            Guide,
+            Start,
+            LeftStick,
+            RightStick,
+            LeftShoulder,
+            RightShoulder,
+            DpadUp,
+            DpadDown,
+            DpadLeft,
+            DpadRight,
+            Max,
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct DeviceEvent
+        {
+            public EventType Type;
+            public uint TimeStamp;
+            public int Which;
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate int d_sdl_gamecontrolleraddmapping(string mappingString);
+        public static d_sdl_gamecontrolleraddmapping AddMapping = FuncLoader.LoadFunction<d_sdl_gamecontrolleraddmapping>(NativeLibrary, "SDL_GameControllerAddMapping");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate int d_sdl_gamecontrolleraddmappingsfromrw(IntPtr rw, int freew);
+        public static d_sdl_gamecontrolleraddmappingsfromrw AddMappingFromRw = FuncLoader.LoadFunction<d_sdl_gamecontrolleraddmappingsfromrw>(NativeLibrary, "SDL_GameControllerAddMappingsFromRW");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_gamecontrollerclose(IntPtr gamecontroller);
+        public static d_sdl_gamecontrollerclose Close = FuncLoader.LoadFunction<d_sdl_gamecontrollerclose>(NativeLibrary, "SDL_GameControllerClose");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_joystickfrominstanceid(int joyid);
+        private static d_sdl_joystickfrominstanceid SDL_GameControllerFromInstanceID = FuncLoader.LoadFunction<d_sdl_joystickfrominstanceid>(NativeLibrary, "SDL_JoystickFromInstanceID");
+
+        public static IntPtr FromInstanceID(int joyid)
+        {
+            return GetError(SDL_GameControllerFromInstanceID(joyid));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate short d_sdl_gamecontrollergetaxis(IntPtr gamecontroller, Axis axis);
+        public static d_sdl_gamecontrollergetaxis GetAxis = FuncLoader.LoadFunction<d_sdl_gamecontrollergetaxis>(NativeLibrary, "SDL_GameControllerGetAxis");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate byte d_sdl_gamecontrollergetbutton(IntPtr gamecontroller, Button button);
+        public static d_sdl_gamecontrollergetbutton GetButton = FuncLoader.LoadFunction<d_sdl_gamecontrollergetbutton>(NativeLibrary, "SDL_GameControllerGetButton");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_gamecontrollergetjoystick(IntPtr gamecontroller);
+        private static d_sdl_gamecontrollergetjoystick SDL_GameControllerGetJoystick = FuncLoader.LoadFunction<d_sdl_gamecontrollergetjoystick>(NativeLibrary, "SDL_GameControllerGetJoystick");
+
+        public static IntPtr GetJoystick(IntPtr gamecontroller)
+        {
+            return GetError(SDL_GameControllerGetJoystick(gamecontroller));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate byte d_sdl_isgamecontroller(int joystickIndex);
+        public static d_sdl_isgamecontroller IsGameController = FuncLoader.LoadFunction<d_sdl_isgamecontroller>(NativeLibrary, "SDL_IsGameController");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_gamecontrollermapping(IntPtr gamecontroller);
+        private static d_sdl_gamecontrollermapping SDL_GameControllerMapping = FuncLoader.LoadFunction<d_sdl_gamecontrollermapping>(NativeLibrary, "SDL_GameControllerMapping");
+
+        public static string GetMapping(IntPtr gamecontroller)
+        {
+            return InteropHelpers.Utf8ToString(SDL_GameControllerMapping(gamecontroller));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_gamecontrolleropen(int joystickIndex);
+        private static d_sdl_gamecontrolleropen SDL_GameControllerOpen = FuncLoader.LoadFunction<d_sdl_gamecontrolleropen>(NativeLibrary, "SDL_GameControllerOpen");
+
+        public static IntPtr Open(int joystickIndex)
+        {
+            return GetError(SDL_GameControllerOpen(joystickIndex));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_gamecontrollername(IntPtr gamecontroller);
+        private static d_sdl_gamecontrollername SDL_GameControllerName = FuncLoader.LoadFunction<d_sdl_gamecontrollername>(NativeLibrary, "SDL_GameControllerName");
+
+        public static string GetName(IntPtr gamecontroller)
+        {
+            return InteropHelpers.Utf8ToString(SDL_GameControllerName(gamecontroller));
+        }
+    }
+
+    public static class Haptic
+    {
+        public const uint Infinity = 4292967295U;
+
+        public enum EffectId : ushort
+        {
+            LeftRight = (1 << 2),
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct LeftRight
+        {
+            public EffectId Type;
+            public uint Length;
+            public ushort LargeMagnitude;
+            public ushort SmallMagnitude;
+        }
+
+        [StructLayout(LayoutKind.Explicit)]
+        public struct Effect
+        {
+            [FieldOffset(0)] public EffectId type;
+            [FieldOffset(0)] public LeftRight leftright;
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate void d_sdl_hapticclose(IntPtr haptic);
+        public static d_sdl_hapticclose Close = FuncLoader.LoadFunction<d_sdl_hapticclose>(NativeLibrary, "SDL_HapticClose");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate int d_sdl_hapticeffectsupported(IntPtr haptic, ref Effect effect);
+        public static d_sdl_hapticeffectsupported EffectSupported = FuncLoader.LoadFunction<d_sdl_hapticeffectsupported>(NativeLibrary, "SDL_HapticEffectSupported");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate int d_sdl_joystickishaptic(IntPtr joystick);
+        public static d_sdl_joystickishaptic IsHaptic = FuncLoader.LoadFunction<d_sdl_joystickishaptic>(NativeLibrary, "SDL_JoystickIsHaptic");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_hapticneweffect(IntPtr haptic, ref Effect effect);
+        private static d_sdl_hapticneweffect SDL_HapticNewEffect = FuncLoader.LoadFunction<d_sdl_hapticneweffect>(NativeLibrary, "SDL_HapticNewEffect");
+
+        public static void NewEffect(IntPtr haptic, ref Effect effect)
+        {
+            GetError(SDL_HapticNewEffect(haptic, ref effect));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        public delegate IntPtr d_sdl_hapticopen(int device_index);
+        public static d_sdl_hapticopen Open = FuncLoader.LoadFunction<d_sdl_hapticopen>(NativeLibrary, "SDL_HapticOpen");
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate IntPtr d_sdl_hapticopenfromjoystick(IntPtr joystick);
+        private static d_sdl_hapticopenfromjoystick SDL_HapticOpenFromJoystick = FuncLoader.LoadFunction<d_sdl_hapticopenfromjoystick>(NativeLibrary, "SDL_HapticOpenFromJoystick");
+
+        public static IntPtr OpenFromJoystick(IntPtr joystick)
+        {
+            return GetError(SDL_HapticOpenFromJoystick(joystick));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_hapticrumbleinit(IntPtr haptic);
+        private static d_sdl_hapticrumbleinit SDL_HapticRumbleInit = FuncLoader.LoadFunction<d_sdl_hapticrumbleinit>(NativeLibrary, "SDL_HapticRumbleInit");
+
+        public static void RumbleInit(IntPtr haptic)
+        {
+            GetError(SDL_HapticRumbleInit(haptic));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_hapticrumbleplay(IntPtr haptic, float strength, uint length);
+        private static d_sdl_hapticrumbleplay SDL_HapticRumblePlay = FuncLoader.LoadFunction<d_sdl_hapticrumbleplay>(NativeLibrary, "SDL_HapticRumblePlay");
+
+        public static void RumblePlay(IntPtr haptic, float strength, uint length)
+        {
+            GetError(SDL_HapticRumblePlay(haptic, strength, length));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_hapticrumblesupported(IntPtr haptic);
+        private static d_sdl_hapticrumblesupported SDL_HapticRumbleSupported = FuncLoader.LoadFunction<d_sdl_hapticrumblesupported>(NativeLibrary, "SDL_HapticRumbleSupported");
+
+        public static int RumbleSupported(IntPtr haptic)
+        {
+            return GetError(SDL_HapticRumbleSupported(haptic));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_hapticruneffect(IntPtr haptic, int effect, uint iterations);
+        private static d_sdl_hapticruneffect SDL_HapticRunEffect = FuncLoader.LoadFunction<d_sdl_hapticruneffect>(NativeLibrary, "SDL_HapticRunEffect");
+
+        public static void RunEffect(IntPtr haptic, int effect, uint iterations)
+        {
+            GetError(SDL_HapticRunEffect(haptic, effect, iterations));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_hapticstopall(IntPtr haptic);
+        private static d_sdl_hapticstopall SDL_HapticStopAll = FuncLoader.LoadFunction<d_sdl_hapticstopall>(NativeLibrary, "SDL_HapticStopAll");
+
+        public static void StopAll(IntPtr haptic)
+        {
+            GetError(SDL_HapticStopAll(haptic));
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate int d_sdl_hapticupdateeffect(IntPtr haptic, int effect, ref Effect data);
+        private static d_sdl_hapticupdateeffect SDL_HapticUpdateEffect = FuncLoader.LoadFunction<d_sdl_hapticupdateeffect>(NativeLibrary, "SDL_HapticUpdateEffect");
+
+        public static void UpdateEffect(IntPtr haptic, int effect, ref Effect data)
+        {
+            GetError(SDL_HapticUpdateEffect(haptic, effect, ref data));
+        }
+    }
+}
diff --git a/MonoGame.Framework/SDL/SDLGamePlatform.cs b/MonoGame.Framework/SDL/SDLGamePlatform.cs
new file mode 100644
index 00000000000..8011179cebd
--- /dev/null
+++ b/MonoGame.Framework/SDL/SDLGamePlatform.cs
@@ -0,0 +1,269 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using System.Runtime.InteropServices;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework
+{
+    internal class SdlGamePlatform : GamePlatform
+    {
+        public override GameRunBehavior DefaultRunBehavior
+        {
+            get { return GameRunBehavior.Synchronous; }
+        }
+
+        private readonly Game _game;
+        private readonly List<Keys> _keys;
+
+        private int _isExiting;
+        private SdlGameWindow _view;
+
+        public SdlGamePlatform(Game game)
+            : base(game)
+        {
+            _game = game;
+            _keys = new List<Keys>();
+            Keyboard.SetKeys(_keys);
+
+            Sdl.Version sversion;
+            Sdl.GetVersion(out sversion);
+
+            Sdl.Major = sversion.Major;
+            Sdl.Minor = sversion.Minor;
+            Sdl.Patch = sversion.Patch;
+
+            var version = 100 * Sdl.Major + 10 * Sdl.Minor + Sdl.Patch;
+
+            if (version <= 204)
+                Debug.WriteLine ("Please use SDL 2.0.5 or higher.");
+
+            // Needed so VS can debug the project on Windows
+            if (version >= 205 && CurrentPlatform.OS == OS.Windows && Debugger.IsAttached)
+                Sdl.SetHint("SDL_WINDOWS_DISABLE_THREAD_NAMING", "1");
+
+            Sdl.Init((int)(
+                Sdl.InitFlags.Video |
+                Sdl.InitFlags.Joystick |
+                Sdl.InitFlags.GameController |
+                Sdl.InitFlags.Haptic
+            ));
+
+            Sdl.DisableScreenSaver();
+
+            GamePad.InitDatabase();
+            Window = _view = new SdlGameWindow(_game);
+        }
+
+        public override void BeforeInitialize ()
+        {
+            SdlRunLoop();
+
+            base.BeforeInitialize ();
+        }
+
+        protected override void OnIsMouseVisibleChanged()
+        {
+            _view.SetCursorVisible(_game.IsMouseVisible);
+        }
+
+        internal override void OnPresentationChanged(PresentationParameters pp)
+        {
+            var displayIndex = Sdl.Window.GetDisplayIndex(Window.Handle);
+            var displayName = Sdl.Display.GetDisplayName(displayIndex);
+            BeginScreenDeviceChange(pp.IsFullScreen);
+            EndScreenDeviceChange(displayName, pp.BackBufferWidth, pp.BackBufferHeight);
+        }
+
+        public override void RunLoop()
+        {
+            Sdl.Window.Show(Window.Handle);
+
+            while (true)
+            {
+                SdlRunLoop();
+                Game.Tick();
+                Threading.Run();
+                GraphicsDevice.DisposeContexts();
+
+                if (_isExiting > 0)
+                    break;
+            }
+        }
+
+        private void SdlRunLoop()
+        {
+            Sdl.Event ev;
+
+            while (Sdl.PollEvent(out ev) == 1)
+            {
+                if (ev.Type == Sdl.EventType.Quit)
+                    _isExiting++;
+                else if (ev.Type == Sdl.EventType.JoyDeviceAdded)
+                    Joystick.AddDevice(ev.JoystickDevice.Which);
+                else if (ev.Type == Sdl.EventType.ControllerDeviceRemoved)
+                    GamePad.RemoveDevice(ev.ControllerDevice.Which);
+                else if (ev.Type == Sdl.EventType.JoyDeviceRemoved)
+                    Joystick.RemoveDevice(ev.JoystickDevice.Which);
+                else if (ev.Type == Sdl.EventType.MouseWheel)
+                {
+                    const int wheelDelta = 120;
+                    Mouse.ScrollY += ev.Wheel.Y * wheelDelta;
+                    Mouse.ScrollX += ev.Wheel.X * wheelDelta;
+                }
+                else if (ev.Type == Sdl.EventType.MouseMotion)
+                {
+                    Window.MouseState.X = ev.Motion.X;
+                    Window.MouseState.Y = ev.Motion.Y;
+                }
+                else if (ev.Type == Sdl.EventType.KeyDown)
+                {
+                    var key = KeyboardUtil.ToXna(ev.Key.Keysym.Sym);
+                    if (!_keys.Contains(key))
+                        _keys.Add(key);
+                    char character = (char)ev.Key.Keysym.Sym;
+                    if (char.IsControl(character))
+                        _view.CallTextInput(character, key);
+                }
+                else if (ev.Type == Sdl.EventType.KeyUp)
+                {
+                    var key = KeyboardUtil.ToXna(ev.Key.Keysym.Sym);
+                    _keys.Remove(key);
+                }
+                else if (ev.Type == Sdl.EventType.TextInput)
+                {
+                    if (_view.IsTextInputHandled)
+                    {
+                        int len = 0;
+                        int utf8character = 0; // using an int to encode multibyte characters longer than 2 bytes
+                        byte currentByte = 0;
+                        int charByteSize = 0; // UTF8 char lenght to decode
+                        unsafe
+                        {
+                            while ((currentByte = Marshal.ReadByte((IntPtr)ev.Text.Text, len)) != 0)
+                            {
+                                // we're reading the first UTF8 byte, we need to check if it's multibyte
+                                if (charByteSize == 0)
+                                {
+                                    if (currentByte < 192)
+                                        charByteSize = 1;
+                                    else if (currentByte < 224)
+                                        charByteSize = 2;
+                                    else if (currentByte < 240)
+                                        charByteSize = 3;
+                                    else
+                                        charByteSize = 4;
+
+                                    utf8character = 0;
+                                }
+
+                                // assembling the character
+                                utf8character <<= 8;
+                                utf8character |= currentByte;
+
+                                charByteSize--;
+                                if (charByteSize == 0) // finished decoding the current character
+                                {
+                                    var key = KeyboardUtil.ToXna(utf8character);
+                                    // multibyte conversion might fail here, because the char type only handles UTF8 up to 2-byte characters
+                                    // we should switch to a String parameter for this event to fully support UTF8
+                                    // as-is, it won't support CJK characters and will produce wrong results
+                                    _view.CallTextInput((char)utf8character, key);
+                                }
+
+                                len++;
+                            }
+                        }
+                    }
+                }
+                else if (ev.Type == Sdl.EventType.WindowEvent)
+                {
+                    if (ev.Window.WindowID == _view.Id)
+                    {
+                        if (ev.Window.EventID == Sdl.Window.EventId.Resized || ev.Window.EventID == Sdl.Window.EventId.SizeChanged)
+                            _view.ClientResize(ev.Window.Data1, ev.Window.Data2);
+                        else if (ev.Window.EventID == Sdl.Window.EventId.FocusGained)
+                            IsActive = true;
+                        else if (ev.Window.EventID == Sdl.Window.EventId.FocusLost)
+                            IsActive = false;
+                        else if (ev.Window.EventID == Sdl.Window.EventId.Moved)
+                            _view.Moved();
+                        else if (ev.Window.EventID == Sdl.Window.EventId.Close)
+                            _isExiting++;
+                    }
+                }
+            }
+        }
+
+        public override void StartRunLoop()
+        {
+            throw new NotSupportedException("The desktop platform does not support asynchronous run loops");
+        }
+
+        public override void Exit()
+        {
+            Interlocked.Increment(ref _isExiting);
+        }
+
+        public override bool BeforeUpdate(GameTime gameTime)
+        {
+            return true;
+        }
+
+        public override bool BeforeDraw(GameTime gameTime)
+        {
+            return true;
+        }
+
+        public override void EnterFullScreen()
+        {
+        }
+
+        public override void ExitFullScreen()
+        {
+        }
+
+        public override void BeginScreenDeviceChange(bool willBeFullScreen)
+        {
+            _view.BeginScreenDeviceChange(willBeFullScreen);
+        }
+
+        public override void EndScreenDeviceChange(string screenDeviceName, int clientWidth, int clientHeight)
+        {
+            _view.EndScreenDeviceChange(screenDeviceName, clientWidth, clientHeight);
+        }
+
+        public override void Log(string message)
+        {
+            Console.WriteLine(message);
+        }
+
+        public override void Present()
+        {
+            if (Game.GraphicsDevice != null)
+                Game.GraphicsDevice.Present();
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (_view != null)
+            {
+                _view.Dispose();
+                _view = null;
+
+                Joystick.CloseDevices();
+
+                Sdl.Quit();
+            }
+
+            base.Dispose(disposing);
+        }
+    }
+}
diff --git a/MonoGame.Framework/SDL/SDLGameWindow.cs b/MonoGame.Framework/SDL/SDLGameWindow.cs
new file mode 100644
index 00000000000..0491e268a90
--- /dev/null
+++ b/MonoGame.Framework/SDL/SDLGameWindow.cs
@@ -0,0 +1,338 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Reflection;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework
+{
+    internal class SdlGameWindow : GameWindow, IDisposable
+    {
+        public override bool AllowUserResizing
+        {
+            get { return !IsBorderless && _resizable; }
+            set
+            {
+                if (Sdl.Patch > 4)
+                    Sdl.Window.SetResizable(_handle, value);
+                else
+                    throw new Exception("SDL 2.0.4 does not support changing resizable parameter of the window after it's already been created, please use a newer version of it.");
+
+                _resizable = value;
+            }
+        }
+
+        public override Rectangle ClientBounds
+        {
+            get
+            {
+                int x = 0, y = 0;
+                Sdl.Window.GetPosition(Handle, out x, out y);
+                return new Rectangle(x, y, _width, _height);
+            }
+        }
+
+        public override Point Position
+        {
+            get
+            {
+                int x = 0, y = 0;
+
+                if (!IsFullScreen)
+                    Sdl.Window.GetPosition(Handle, out x, out y);
+
+                return new Point(x, y);
+            }
+            set
+            {
+                Sdl.Window.SetPosition(Handle, value.X, value.Y);
+                _wasMoved = true;
+            }
+        }
+
+        public override DisplayOrientation CurrentOrientation
+        {
+            get { return DisplayOrientation.Default; }
+        }
+
+        public override IntPtr Handle
+        {
+            get { return _handle; }
+        }
+
+        public override string ScreenDeviceName
+        {
+            get { return _screenDeviceName; }
+        }
+
+        public override bool IsBorderless
+        {
+            get { return _borderless; }
+            set
+            {
+                Sdl.Window.SetBordered(_handle, value ? 0 : 1);
+                _borderless = value;
+            }
+        }
+
+        public static GameWindow Instance;
+        public uint? Id;
+        public bool IsFullScreen;
+
+        internal readonly Game _game;
+        private IntPtr _handle, _icon;
+        private bool _disposed;
+        private bool _resizable, _borderless, _willBeFullScreen, _mouseVisible, _hardwareSwitch;
+        private string _screenDeviceName;
+        private int _width, _height;
+        private bool _wasMoved, _supressMoved;
+
+        public SdlGameWindow(Game game)
+        {
+            _game = game;
+            _screenDeviceName = "";
+
+            Instance = this;
+
+            _width = GraphicsDeviceManager.DefaultBackBufferWidth;
+            _height = GraphicsDeviceManager.DefaultBackBufferHeight;
+
+            Sdl.SetHint("SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS", "0");
+            Sdl.SetHint("SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS", "1");
+
+            // when running NUnit tests entry assembly can be null
+            if (Assembly.GetEntryAssembly() != null)
+            {
+                using (
+                    var stream =
+                        Assembly.GetEntryAssembly().GetManifestResourceStream(Assembly.GetEntryAssembly().EntryPoint.DeclaringType.Namespace + ".Icon.bmp") ??
+                        Assembly.GetEntryAssembly().GetManifestResourceStream("Icon.bmp") ??
+                        Assembly.GetExecutingAssembly().GetManifestResourceStream("MonoGame.bmp"))
+                {
+                    if (stream != null)
+                        using (var br = new BinaryReader(stream))
+                        {
+                            try
+                            {
+                                var src = Sdl.RwFromMem(br.ReadBytes((int)stream.Length), (int)stream.Length);
+                                _icon = Sdl.LoadBMP_RW(src, 1);
+                            }
+                            catch { }
+                        }
+                }
+            }
+
+            _handle = Sdl.Window.Create("", 0, 0,
+                GraphicsDeviceManager.DefaultBackBufferWidth, GraphicsDeviceManager.DefaultBackBufferHeight,
+                Sdl.Window.State.Hidden);
+        }
+
+        internal void CreateWindow()
+        {
+            var initflags =
+                Sdl.Window.State.OpenGL |
+                Sdl.Window.State.Hidden |
+                Sdl.Window.State.InputFocus |
+                Sdl.Window.State.MouseFocus;
+
+            if (_handle != IntPtr.Zero)
+                Sdl.Window.Destroy(_handle);
+
+            var winx = Sdl.Window.PosCentered;
+            var winy = Sdl.Window.PosCentered;
+
+            // if we are on Linux, start on the current screen
+            if (CurrentPlatform.OS == OS.Linux)
+            {
+                winx |= GetMouseDisplay();
+                winy |= GetMouseDisplay();
+            }
+
+            _handle = Sdl.Window.Create(AssemblyHelper.GetDefaultWindowTitle(),
+                winx, winy, _width, _height, initflags);
+
+            Id = Sdl.Window.GetWindowId(_handle);
+
+            if (_icon != IntPtr.Zero)
+                Sdl.Window.SetIcon(_handle, _icon);
+
+            Sdl.Window.SetBordered(_handle, _borderless ? 0 : 1);
+            Sdl.Window.SetResizable(_handle, _resizable);
+
+            SetCursorVisible(_mouseVisible);
+        }
+
+        ~SdlGameWindow()
+        {
+            Dispose(false);
+        }
+
+        private static int GetMouseDisplay()
+        {
+            var rect = new Sdl.Rectangle();
+
+            int x, y;
+            Sdl.Mouse.GetGlobalState(out x, out y);
+
+            var displayCount = Sdl.Display.GetNumVideoDisplays();
+            for (var i = 0; i < displayCount; i++)
+            {
+                Sdl.Display.GetBounds(i, out rect);
+
+                if (x >= rect.X && x < rect.X + rect.Width &&
+                    y >= rect.Y && y < rect.Y + rect.Height)
+                {
+                    return i;
+                }
+            }
+
+            return 0;
+        }
+
+        public void SetCursorVisible(bool visible)
+        {
+            _mouseVisible = visible;
+            Sdl.Mouse.ShowCursor(visible ? 1 : 0);
+        }
+
+        public override void BeginScreenDeviceChange(bool willBeFullScreen)
+        {
+            _willBeFullScreen = willBeFullScreen;
+        }
+
+        public override void EndScreenDeviceChange(string screenDeviceName, int clientWidth, int clientHeight)
+        {
+            _screenDeviceName = screenDeviceName;
+
+            var prevBounds = ClientBounds;
+            var displayIndex = Sdl.Window.GetDisplayIndex(Handle);
+
+            Sdl.Rectangle displayRect;
+            Sdl.Display.GetBounds(displayIndex, out displayRect);
+
+            if (_willBeFullScreen != IsFullScreen || _hardwareSwitch != _game.graphicsDeviceManager.HardwareModeSwitch)
+            {
+                var fullscreenFlag = _game.graphicsDeviceManager.HardwareModeSwitch ? Sdl.Window.State.Fullscreen : Sdl.Window.State.FullscreenDesktop;
+                Sdl.Window.SetFullscreen(Handle, (_willBeFullScreen) ? fullscreenFlag : 0);
+                _hardwareSwitch = _game.graphicsDeviceManager.HardwareModeSwitch;
+            }
+            // If going to exclusive full-screen mode, force the window to minimize on focus loss (Windows only)
+            if (CurrentPlatform.OS == OS.Windows)
+            {
+                Sdl.SetHint("SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS", _willBeFullScreen && _hardwareSwitch ? "1" : "0");
+            }
+
+            if (!_willBeFullScreen || _game.graphicsDeviceManager.HardwareModeSwitch)
+            {
+                Sdl.Window.SetSize(Handle, clientWidth, clientHeight);
+                _width = clientWidth;
+                _height = clientHeight;
+            }
+            else
+            {
+                _width = displayRect.Width;
+                _height = displayRect.Height;
+            }
+
+            int ignore, minx = 0, miny = 0;
+            Sdl.Window.GetBorderSize(_handle, out miny, out minx, out ignore, out ignore);
+
+            var centerX = Math.Max(prevBounds.X + ((prevBounds.Width - clientWidth) / 2), minx);
+            var centerY = Math.Max(prevBounds.Y + ((prevBounds.Height - clientHeight) / 2), miny);
+
+            if (IsFullScreen && !_willBeFullScreen)
+            {
+                // We need to get the display information again in case
+                // the resolution of it was changed.
+                Sdl.Display.GetBounds (displayIndex, out displayRect);
+
+                // This centering only occurs when exiting fullscreen
+                // so it should center the window on the current display.
+                centerX = displayRect.X + displayRect.Width / 2 - clientWidth / 2;
+                centerY = displayRect.Y + displayRect.Height / 2 - clientHeight / 2;
+            }
+
+            // If this window is resizable, there is a bug in SDL 2.0.4 where
+            // after the window gets resized, window position information
+            // becomes wrong (for me it always returned 10 8). Solution is
+            // to not try and set the window position because it will be wrong.
+            if ((Sdl.Patch > 4 || !AllowUserResizing) && !_wasMoved)
+                Sdl.Window.SetPosition(Handle, centerX, centerY);
+
+            if (IsFullScreen != _willBeFullScreen)
+                OnClientSizeChanged();
+
+            IsFullScreen = _willBeFullScreen;
+
+            _supressMoved = true;
+        }
+
+        internal void Moved()
+        {
+            if (_supressMoved)
+            {
+                _supressMoved = false;
+                return;
+            }
+
+            _wasMoved = true;
+        }
+
+        public void ClientResize(int width, int height)
+        {
+            // SDL reports many resize events even if the Size didn't change.
+            // Only call the code below if it actually changed.
+            if (_game.GraphicsDevice.PresentationParameters.BackBufferWidth == width &&
+                _game.GraphicsDevice.PresentationParameters.BackBufferHeight == height) {
+                return;
+            }
+            _game.GraphicsDevice.PresentationParameters.BackBufferWidth = width;
+            _game.GraphicsDevice.PresentationParameters.BackBufferHeight = height;
+            _game.GraphicsDevice.Viewport = new Viewport(0, 0, width, height);
+
+            Sdl.Window.GetSize(Handle, out _width, out _height);
+
+            OnClientSizeChanged();
+        }
+
+        public void CallTextInput(char c, Keys key = Keys.None)
+        {
+            OnTextInput(this, new TextInputEventArgs(c, key));
+        }
+
+        protected internal override void SetSupportedOrientations(DisplayOrientation orientations)
+        {
+            // Nothing to do here
+        }
+
+        protected override void SetTitle(string title)
+        {
+            Sdl.Window.SetTitle(_handle, title);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+                return;
+
+            Sdl.Window.Destroy(_handle);
+            _handle = IntPtr.Zero;
+
+            if (_icon != IntPtr.Zero)
+                Sdl.FreeSurface(_icon);
+
+            _disposed = true;
+        }
+    }
+}
diff --git a/MonoGame.Framework/TextInputEventArgs.cs b/MonoGame.Framework/TextInputEventArgs.cs
new file mode 100644
index 00000000000..286247e8586
--- /dev/null
+++ b/MonoGame.Framework/TextInputEventArgs.cs
@@ -0,0 +1,32 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework.Input;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// This class is used for the game window's TextInput event as EventArgs.
+    /// </summary>
+    public class TextInputEventArgs : EventArgs
+    {
+        char character;
+        public TextInputEventArgs(char character, Keys key = Keys.None)
+        {
+            this.character = character;
+            this.Key = key;
+        }
+        public char Character
+        {
+            get
+            {
+                return character;
+            }
+        }
+        public Keys Key {
+            get; private set;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Themes/generic.xaml b/MonoGame.Framework/Themes/generic.xaml
new file mode 100644
index 00000000000..21344f92123
--- /dev/null
+++ b/MonoGame.Framework/Themes/generic.xaml
@@ -0,0 +1,226 @@
+<ResourceDictionary
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:input="using:Microsoft.Xna.Framework.Input">
+
+    <Style TargetType="input:InputDialog">
+        <Setter
+            Property="BackgroundScreenBrush"
+            Value="#80000000" />
+        <Setter
+            Property="BackgroundStripeBrush"
+            Value="#80000000" />
+        <Setter
+            Property="Padding"
+            Value="15" />
+        <Setter
+            Property="TitleStyle">
+            <Setter.Value>
+                <Style
+                    TargetType="TextBlock">
+                    <Setter
+                        Property="FontFamily"
+                        Value="Segoe UI" />
+                    <Setter
+                        Property="FontSize"
+                        Value="24" />
+                    <Setter
+                        Property="Margin"
+                        Value="3,0" />
+                    <Setter
+                        Property="Foreground"
+                        Value="White" />
+                </Style>
+            </Setter.Value>
+        </Setter>
+        <Setter
+            Property="TextStyle">
+            <Setter.Value>
+                <Style
+                    TargetType="TextBlock">
+                    <Setter
+                        Property="FontFamily"
+                        Value="Segoe UI Semilight" />
+                    <Setter
+                        Property="FontSize"
+                        Value="16" />
+                    <Setter
+                        Property="Margin"
+                        Value="3,10,3,5" />
+                    <Setter
+                        Property="TextWrapping"
+                        Value="Wrap" />
+                    <Setter
+                        Property="Foreground"
+                        Value="White" />
+                </Style>
+            </Setter.Value>
+        </Setter>
+        <Setter
+            Property="InputTextStyle">
+            <Setter.Value>
+                <Style
+                    TargetType="TextBox">
+                    <Setter
+                        Property="Margin"
+                        Value="0,10,10,10" />
+                    <Setter
+                        Property="TextWrapping"
+                        Value="Wrap" />
+                    <Setter
+                        Property="BorderBrush"
+                        Value="Black" />
+                    <Setter 
+						Property="FontSize"
+						Value="16" />
+                    <Setter
+                        Property="MinHeight"
+                        Value="30" />
+                    <Setter
+                        Property="Background"
+                        Value="White" />
+                </Style>
+            </Setter.Value>
+        </Setter>
+        <Setter
+            Property="InputPasswordStyle">
+            <Setter.Value>
+                <Style
+                    TargetType="PasswordBox">
+                    <Setter
+                        Property="Margin"
+                        Value="5,5,5,5" />
+                    <Setter
+                        Property="BorderBrush"
+                        Value="Black" />
+                </Style>
+            </Setter.Value>
+        </Setter>
+        <Setter
+            Property="ButtonStyle">
+            <Setter.Value>
+                <Style
+                    TargetType="ButtonBase">
+                    <Setter
+                        Property="Foreground"
+                        Value="#FFFFFF" />
+                    <Setter
+                        Property="Margin"
+                        Value="5" />
+                    <Setter
+                        Property="FontSize"
+                        Value="16" />
+                </Style>
+            </Setter.Value>
+        </Setter>
+        <Setter
+            Property="Template">
+            <Setter.Value>
+                <ControlTemplate
+                    TargetType="input:InputDialog">
+                    <Grid
+                        x:Name="LayoutRoot"
+                        Background="{TemplateBinding BackgroundScreenBrush}">
+                        <VisualStateManager.VisualStateGroups>
+                            <VisualStateGroup
+                                x:Name="PopupStates">
+                                <VisualState
+                                    x:Name="OpenPopupState">
+                                    <Storyboard>
+                                        <ObjectAnimationUsingKeyFrames
+                                            Storyboard.TargetName="LayoutRoot"
+                                            Storyboard.TargetProperty="Visibility">
+                                            <DiscreteObjectKeyFrame
+                                                KeyTime="0:0:0"
+                                                Value="Visible" />
+                                        </ObjectAnimationUsingKeyFrames>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="LayoutRoot"
+                                            Storyboard.TargetProperty="Opacity"
+                                            From="0"
+                                            To="1"
+                                            Duration="0:0:0.4">
+                                            <DoubleAnimation.EasingFunction>
+                                                <PowerEase
+                                                    EasingMode="EaseOut"
+                                                    Power="3" />
+                                            </DoubleAnimation.EasingFunction>
+                                        </DoubleAnimation>
+                                    </Storyboard>
+                                </VisualState>
+                                <VisualState
+                                    x:Name="ClosedPopupState">
+                                    <Storyboard>
+                                        <DoubleAnimation
+                                            Storyboard.TargetName="LayoutRoot"
+                                            Storyboard.TargetProperty="Opacity"
+                                            From="1"
+                                            To="0"
+                                            Duration="0:0:.4">
+                                            <DoubleAnimation.EasingFunction>
+                                                <PowerEase
+                                                    EasingMode="EaseOut"
+                                                    Power="3" />
+                                            </DoubleAnimation.EasingFunction>
+                                        </DoubleAnimation>
+                                    </Storyboard>
+                                </VisualState>
+                            </VisualStateGroup>
+                        </VisualStateManager.VisualStateGroups>
+                        <Grid.Resources>
+                            <Storyboard x:Key="VirtualKeyboardSlideStoryBoard" x:Name="VirtualKeyboardSlideStoryBoard">
+                                <DoubleAnimation x:Name="VirtualKeyboardAnimation" 
+                                                 To="0" 
+                                                 Duration="0:0:0.4" 
+                                                 Storyboard.TargetName="BlackStripeTransform" 
+                                                 Storyboard.TargetProperty="Y">
+                                    <DoubleAnimation.EasingFunction>
+                                        <CircleEase EasingMode="EaseOut" />
+                                    </DoubleAnimation.EasingFunction>
+                                </DoubleAnimation>
+                            </Storyboard>
+                        </Grid.Resources>
+                    	<Border
+                    		x:Name="BlackStripe"
+                    		Background="{TemplateBinding BackgroundStripeBrush}"
+                    		VerticalAlignment="Center"
+                    		HorizontalAlignment="Stretch"
+                    		Height="500"
+							>
+                            <Border.RenderTransform >
+                                <TranslateTransform x:Name="BlackStripeTransform" />
+                            </Border.RenderTransform>
+                    		<Border
+                    			x:Name="ContentBorder"
+                    			VerticalAlignment="Center"
+                    			HorizontalAlignment="Center"
+                    			Margin="0">
+                    			<StackPanel
+                    				x:Name="ContentPanel"
+                    				Margin="{TemplateBinding Padding}"
+                    				MinWidth="600">
+                    				<TextBlock
+                    					x:Name="TitleTextBlock"
+                    					Style="{TemplateBinding TitleStyle}" />
+                    				<TextBlock
+                    					x:Name="TextTextBlock"
+                    					Style="{TemplateBinding TextStyle}" />
+                    				<TextBox
+                    					x:Name="InputTextBox"
+                    					Style="{TemplateBinding InputTextStyle}" />
+                    				<PasswordBox
+                    					x:Name="InputPasswordBox"
+                    					Style="{TemplateBinding InputPasswordStyle}" />
+                    				<StackPanel
+                    					x:Name="ButtonsPanel"
+                    					Orientation="{TemplateBinding ButtonsPanelOrientation}"
+                    					HorizontalAlignment="Right" />
+                    			</StackPanel>
+                    		</Border>
+                    	</Border>
+                    </Grid>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+</ResourceDictionary>
diff --git a/MonoGame.Framework/Threading.cs b/MonoGame.Framework/Threading.cs
new file mode 100644
index 00000000000..7565a4d77a0
--- /dev/null
+++ b/MonoGame.Framework/Threading.cs
@@ -0,0 +1,137 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using Microsoft.Xna.Framework.Graphics;
+#if IOS
+using Foundation;
+using OpenGLES;
+#endif
+#if DESKTOPGL || ANGLE || GLES
+using MonoGame.OpenGL;
+#endif
+
+namespace Microsoft.Xna.Framework
+{
+    internal class Threading
+    {
+        public const int kMaxWaitForUIThread = 750; // In milliseconds
+
+        static int mainThreadId;
+
+#if ANDROID || WINDOWS || DESKTOPGL || ANGLE
+        static List<Action> actions = new List<Action>();
+        //static Mutex actionsMutex = new Mutex();
+#elif IOS
+        public static EAGLContext BackgroundContext;
+#endif
+
+        static Threading()
+        {
+            mainThreadId = Thread.CurrentThread.ManagedThreadId;
+        }
+#if ANDROID
+        internal static void ResetThread (int id)
+        {
+            mainThreadId = id;
+        }
+#endif
+        /// <summary>
+        /// Checks if the code is currently running on the UI thread.
+        /// </summary>
+        /// <returns>true if the code is currently running on the UI thread.</returns>
+        public static bool IsOnUIThread()
+        {
+            return mainThreadId == Thread.CurrentThread.ManagedThreadId;
+        }
+
+        /// <summary>
+        /// Throws an exception if the code is not currently running on the UI thread.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">Thrown if the code is not currently running on the UI thread.</exception>
+        public static void EnsureUIThread()
+        {
+            if (!IsOnUIThread())
+                throw new InvalidOperationException("Operation not called on UI thread.");
+        }
+
+        /// <summary>
+        /// Runs the given action on the UI thread and blocks the current thread while the action is running.
+        /// If the current thread is the UI thread, the action will run immediately.
+        /// </summary>
+        /// <param name="action">The action to be run on the UI thread</param>
+        internal static void BlockOnUIThread(Action action)
+        {
+            if (action == null)
+                throw new ArgumentNullException("action");
+
+#if DIRECTX || PSM
+            action();
+#else
+            // If we are already on the UI thread, just call the action and be done with it
+            if (IsOnUIThread())
+            {
+                action();
+                return;
+            }
+
+#if IOS
+            lock (BackgroundContext)
+            {
+                // Make the context current on this thread if it is not already
+                if (!Object.ReferenceEquals(EAGLContext.CurrentContext, BackgroundContext))
+                    EAGLContext.SetCurrentContext(BackgroundContext);
+                // Execute the action
+                action();
+                // Must flush the GL calls so the GPU asset is ready for the main context to use it
+                GL.Flush();
+                GraphicsExtensions.CheckGLError();
+            }
+#else
+            ManualResetEventSlim resetEvent = new ManualResetEventSlim(false);
+            Add(() =>
+            {
+#if ANDROID
+                //if (!Game.Instance.Window.GraphicsContext.IsCurrent)
+                ((AndroidGameWindow)Game.Instance.Window).GameView.MakeCurrent();
+#endif
+                action();
+                resetEvent.Set();
+            });
+            resetEvent.Wait();
+#endif
+#endif
+        }
+
+#if ANDROID || WINDOWS || DESKTOPGL || ANGLE
+        static void Add(Action action)
+        {
+            lock (actions)
+            {
+                actions.Add(action);
+            }
+        }
+
+        /// <summary>
+        /// Runs all pending actions.  Must be called from the UI thread.
+        /// </summary>
+        internal static void Run()
+        {
+            EnsureUIThread();
+
+            lock (actions)
+            {
+                foreach (Action action in actions)
+                {
+                    action();
+                }
+                actions.Clear();
+            }
+        }
+#endif
+    }
+}
diff --git a/MonoGame.Framework/TitleContainer.Android.cs b/MonoGame.Framework/TitleContainer.Android.cs
new file mode 100644
index 00000000000..5bcfea1d31a
--- /dev/null
+++ b/MonoGame.Framework/TitleContainer.Android.cs
@@ -0,0 +1,18 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+
+namespace Microsoft.Xna.Framework
+{
+    partial class TitleContainer
+    {
+        private static Stream PlatformOpenStream(string safeName)
+        {
+            return Android.App.Application.Context.Assets.Open(safeName);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/TitleContainer.Desktop.cs b/MonoGame.Framework/TitleContainer.Desktop.cs
new file mode 100644
index 00000000000..21e1c83f929
--- /dev/null
+++ b/MonoGame.Framework/TitleContainer.Desktop.cs
@@ -0,0 +1,34 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework
+{
+    partial class TitleContainer
+    {
+        static partial void PlatformInit()
+        {
+#if WINDOWS || DESKTOPGL
+#if DESKTOPGL
+            // Check for the package Resources Folder first. This is where the assets
+            // will be bundled.
+            if (CurrentPlatform.OS == OS.MacOSX)
+                Location = Path.Combine (AppDomain.CurrentDomain.BaseDirectory, "..", "Resources");
+            if (!Directory.Exists (Location))
+#endif
+            Location = AppDomain.CurrentDomain.BaseDirectory;
+#endif
+        }
+
+        private static Stream PlatformOpenStream(string safeName)
+        {
+            var absolutePath = Path.Combine(Location, safeName);
+            return File.OpenRead(absolutePath);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/TitleContainer.MacOS.cs b/MonoGame.Framework/TitleContainer.MacOS.cs
new file mode 100644
index 00000000000..3c5ec5e9d8c
--- /dev/null
+++ b/MonoGame.Framework/TitleContainer.MacOS.cs
@@ -0,0 +1,57 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+#if IOS
+using Foundation;
+using UIKit;
+#elif MONOMAC
+using Foundation;
+#endif
+
+namespace Microsoft.Xna.Framework
+{
+    partial class TitleContainer
+    {
+        static partial void PlatformInit()
+        {
+            Location = NSBundle.MainBundle.ResourcePath;
+#if IOS
+            SupportRetina = UIScreen.MainScreen.Scale >= 2.0f;
+            RetinaScale = (int)Math.Round(UIScreen.MainScreen.Scale);
+#endif
+        }
+
+#if IOS
+        static internal bool SupportRetina { get; private set; }
+        static internal int RetinaScale { get; private set; }
+#endif
+
+        private static Stream PlatformOpenStream(string safeName)
+        {
+#if IOS
+            var absolutePath = Path.Combine(Location, safeName);
+            if (SupportRetina)
+            {
+                for (var scale = RetinaScale; scale >= 2; scale--)
+                {
+                    // Insert the @#x immediately prior to the extension. If this file exists
+                    // and we are on a Retina device, return this file instead.
+                    var absolutePathX = Path.Combine(Path.GetDirectoryName(absolutePath),
+                                                      Path.GetFileNameWithoutExtension(absolutePath)
+                                                      + "@" + scale + "x" + Path.GetExtension(absolutePath));
+                    if (File.Exists(absolutePathX))
+                        return File.OpenRead(absolutePathX);
+                }
+            }
+            return File.OpenRead(absolutePath);
+#else
+            var absolutePath = Path.Combine(Location, safeName);
+            return File.OpenRead(absolutePath);
+#endif
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/TitleContainer.WinRT.cs b/MonoGame.Framework/TitleContainer.WinRT.cs
new file mode 100644
index 00000000000..d551322cda2
--- /dev/null
+++ b/MonoGame.Framework/TitleContainer.WinRT.cs
@@ -0,0 +1,57 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.Resources.Core;
+
+namespace Microsoft.Xna.Framework
+{
+    partial class TitleContainer
+    {
+        static internal ResourceContext ResourceContext;
+        static internal ResourceMap FileResourceMap;
+
+        static partial void PlatformInit()
+        {
+            Location = Windows.ApplicationModel.Package.Current.InstalledLocation.Path;
+
+            ResourceContext = new Windows.ApplicationModel.Resources.Core.ResourceContext();
+            FileResourceMap = ResourceManager.Current.MainResourceMap.GetSubtree("Files");
+        }
+
+        private static async Task<Stream> OpenStreamAsync(string name)
+        {
+            NamedResource result;
+
+            if (FileResourceMap != null && FileResourceMap.TryGetValue(name, out result))
+            {
+                var resolved = result.Resolve(ResourceContext);
+
+                try
+                {
+                    var storageFile = await resolved.GetValueAsFileAsync();
+                    var randomAccessStream = await storageFile.OpenReadAsync();
+                    return randomAccessStream.AsStreamForRead();
+                }
+                catch (IOException)
+                {
+                    // The file must not exist... return a null stream.
+                    return null;
+                }
+            }
+            else
+            {
+                return null;
+            }
+        }
+
+        private static Stream PlatformOpenStream(string safeName)
+        {
+            return Task.Run(() => OpenStreamAsync(safeName).Result).Result;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/TitleContainer.cs b/MonoGame.Framework/TitleContainer.cs
new file mode 100644
index 00000000000..60b32539e08
--- /dev/null
+++ b/MonoGame.Framework/TitleContainer.cs
@@ -0,0 +1,75 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using MonoGame.Utilities;
+
+namespace Microsoft.Xna.Framework
+{
+    public static partial class TitleContainer
+    {
+        static partial void PlatformInit();
+
+        static TitleContainer() 
+        {
+            Location = string.Empty;
+            PlatformInit();
+        }
+
+        static internal string Location { get; private set; }
+
+        /// <summary>
+        /// Returns an open stream to an exsiting file in the title storage area.
+        /// </summary>
+        /// <param name="name">The filepath relative to the title storage area.</param>
+        /// <returns>A open stream or null if the file is not found.</returns>
+        public static Stream OpenStream(string name)
+        {
+            if (string.IsNullOrEmpty(name))
+                throw new ArgumentNullException("name");
+
+            // We do not accept absolute paths here.
+            if (Path.IsPathRooted(name))
+                throw new ArgumentException("Invalid filename. TitleContainer.OpenStream requires a relative path.", name);
+
+            // Normalize the file path.
+            var safeName = NormalizeRelativePath(name);
+
+            // Call the platform code to open the stream.  Any errors
+            // at this point should result in a file not found.
+            Stream stream;
+            try
+            {
+                stream = PlatformOpenStream(safeName);
+                if (stream == null)
+                    throw FileNotFoundException(name, null);
+            }
+            catch (FileNotFoundException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                throw new FileNotFoundException(name, ex);
+            }
+
+            return stream;
+        }
+
+        private static Exception FileNotFoundException(string name, Exception inner)
+        {
+            return new FileNotFoundException("Error loading \"" + name + "\". File not found.", inner);
+        }
+
+        internal static string NormalizeRelativePath(string name)
+        {
+            var uri = new Uri("file:///" + name);
+            var path = uri.LocalPath;
+            path = path.Substring(1);
+            return path.Replace(FileHelpers.NotSeparator, FileHelpers.Separator);
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Utilities/AssemblyHelper.cs b/MonoGame.Framework/Utilities/AssemblyHelper.cs
new file mode 100644
index 00000000000..f86667f8ad6
--- /dev/null
+++ b/MonoGame.Framework/Utilities/AssemblyHelper.cs
@@ -0,0 +1,41 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Reflection;
+
+namespace MonoGame.Utilities
+{
+    internal static class AssemblyHelper
+    {
+        public static string GetDefaultWindowTitle()
+        {
+            // Set the window title.
+            string windowTitle = string.Empty;
+
+            // When running unit tests this can return null.
+            var assembly = Assembly.GetEntryAssembly();
+            if (assembly != null)
+            {
+                // Use the Title attribute of the Assembly if possible.
+                try
+                {
+                    var assemblyTitleAtt = ((AssemblyTitleAttribute)Attribute.GetCustomAttribute(assembly, typeof(AssemblyTitleAttribute)));
+                    if (assemblyTitleAtt != null)
+                        windowTitle = assemblyTitleAtt.Title;
+                }
+                catch
+                {
+                    // Nope, wasn't possible :/
+                }
+
+                // Otherwise, fallback to the Name of the assembly.
+                if (string.IsNullOrEmpty(windowTitle))
+                    windowTitle = assembly.GetName().Name;
+            }
+
+            return windowTitle;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/ByteBufferPool.cs b/MonoGame.Framework/Utilities/ByteBufferPool.cs
new file mode 100644
index 00000000000..50af8548e37
--- /dev/null
+++ b/MonoGame.Framework/Utilities/ByteBufferPool.cs
@@ -0,0 +1,88 @@
+using System.Collections.Generic;
+
+namespace MonoGame.Utilities
+{
+    internal class ByteBufferPool
+    {
+        public int FreeAmount
+        {
+            get { return _freeBuffers.Count; }
+        }
+
+        private readonly List<byte[]> _freeBuffers;
+
+        public ByteBufferPool()
+        {
+            _freeBuffers = new List<byte[]>();
+        }
+
+        /// <summary>
+        /// Get a buffer that is at least as big as size.
+        /// </summary>
+        public byte[] Get(int size)
+        {
+            byte[] result;
+            lock (_freeBuffers)
+            {
+                var index = FirstLargerThan(size);
+
+                if (index == -1)
+                {
+                    result = new byte[size];
+                }
+                else
+                {
+                    result = _freeBuffers[index];
+                    _freeBuffers.RemoveAt(index);
+                }
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Return the given buffer to the pool.
+        /// </summary>
+        /// <param name="buffer"></param>
+        public void Return(byte[] buffer)
+        {
+            lock (_freeBuffers)
+            {
+                var index = FirstLargerThan(buffer.Length);
+                if (index == -1)
+                    _freeBuffers.Add(buffer);
+                else
+                    _freeBuffers.Insert(index, buffer);
+            }
+        }
+
+        // Find the smallest buffer that is larger than or equally large as size or -1 if none exist
+        private int FirstLargerThan(int size)
+        {
+            if (_freeBuffers.Count == 0) return -1;
+
+            var l = 0;
+            var r = _freeBuffers.Count - 1;
+
+            while (l <= r)
+            {
+                var m = (l + r)/2;
+                var buffer = _freeBuffers[m];
+                if (buffer.Length < size)
+                {
+                    l = m + 1;
+                }
+                else if (buffer.Length > size)
+                {
+                    r = m;
+                    if (l == r) return l;
+                }
+                else
+                {
+                    return m;
+                }
+            }
+
+            return -1;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/CurrentPlatform.cs b/MonoGame.Framework/Utilities/CurrentPlatform.cs
new file mode 100644
index 00000000000..0f9d2541c45
--- /dev/null
+++ b/MonoGame.Framework/Utilities/CurrentPlatform.cs
@@ -0,0 +1,86 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Runtime.InteropServices;
+using System;
+
+namespace MonoGame.Utilities
+{
+    internal enum OS
+    {
+        Windows,
+        Linux,
+        MacOSX,
+        Unknown
+    }
+
+    internal static class CurrentPlatform
+    {
+        private static bool init = false;
+        private static OS os;
+
+        [DllImport ("libc")]
+        static extern int uname (IntPtr buf);
+
+        private static void Init()
+        {
+            if (!init)
+            {
+                PlatformID pid = Environment.OSVersion.Platform;
+
+                switch (pid) 
+                {
+                    case PlatformID.Win32NT:
+                    case PlatformID.Win32S:
+                    case PlatformID.Win32Windows:
+                    case PlatformID.WinCE:
+                        os = OS.Windows;
+                        break;
+                    case PlatformID.MacOSX:
+                        os = OS.MacOSX;
+                        break;
+                    case PlatformID.Unix:
+
+                        // Mac can return a value of Unix sometimes, We need to double check it.
+                        IntPtr buf = IntPtr.Zero;
+                        try
+                        {
+                            buf = Marshal.AllocHGlobal (8192);
+
+                            if (uname (buf) == 0) {
+                                string sos = Marshal.PtrToStringAnsi (buf);
+                                if (sos == "Darwin")
+                                {
+                                    os = OS.MacOSX;
+                                    return;
+                                }
+                            }
+                        } catch {
+                        } finally {
+                            if (buf != IntPtr.Zero)
+                                Marshal.FreeHGlobal (buf);
+                        }
+
+                        os = OS.Linux;
+                        break;
+                    default:
+                        os = OS.Unknown;
+                        break;
+                }
+
+                init = true;
+            }
+        }
+
+        public static OS OS
+        {
+            get
+            {
+                Init();
+                return os;
+            }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Utilities/Deflate/CRC32.cs b/MonoGame.Framework/Utilities/Deflate/CRC32.cs
new file mode 100644
index 00000000000..1eeff3c1d54
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Deflate/CRC32.cs
@@ -0,0 +1,808 @@
+// CRC32.cs
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2011 Dino Chiesa.
+// All rights reserved.
+//
+// This code module is part of DotNetZip, a zipfile class library.
+//
+// ------------------------------------------------------------------
+//
+// This code is licensed under the Microsoft Public License.
+// See the file License.txt for the license details.
+// More info on: http://dotnetzip.codeplex.com
+//
+// ------------------------------------------------------------------
+//
+// Last Saved: <2011-August-02 18:25:54>
+//
+// ------------------------------------------------------------------
+//
+// This module defines the CRC32 class, which can do the CRC32 algorithm, using
+// arbitrary starting polynomials, and bit reversal. The bit reversal is what
+// distinguishes this CRC-32 used in BZip2 from the CRC-32 that is used in PKZIP
+// files, or GZIP files. This class does both.
+//
+// ------------------------------------------------------------------
+
+
+using System;
+
+namespace MonoGame.Utilities.Deflate
+{
+    /// <summary>
+    ///   Computes a CRC-32. The CRC-32 algorithm is parameterized - you
+    ///   can set the polynomial and enable or disable bit
+    ///   reversal. This can be used for GZIP, BZip2, or ZIP.
+    /// </summary>
+    /// <remarks>
+    ///   This type is used internally by DotNetZip; it is generally not used
+    ///   directly by applications wishing to create, read, or manipulate zip
+    ///   archive files.
+    /// </remarks>
+
+    public class CRC32
+    {
+        /// <summary>
+        ///   Indicates the total number of bytes applied to the CRC.
+        /// </summary>
+        public Int64 TotalBytesRead
+        {
+            get
+            {
+                return _TotalBytesRead;
+            }
+        }
+
+        /// <summary>
+        /// Indicates the current CRC for all blocks slurped in.
+        /// </summary>
+        public Int32 Crc32Result
+        {
+            get
+            {
+                return unchecked((Int32)(~_register));
+            }
+        }
+
+        /// <summary>
+        /// Returns the CRC32 for the specified stream.
+        /// </summary>
+        /// <param name="input">The stream over which to calculate the CRC32</param>
+        /// <returns>the CRC32 calculation</returns>
+        public Int32 GetCrc32(System.IO.Stream input)
+        {
+            return GetCrc32AndCopy(input, null);
+        }
+
+        /// <summary>
+        /// Returns the CRC32 for the specified stream, and writes the input into the
+        /// output stream.
+        /// </summary>
+        /// <param name="input">The stream over which to calculate the CRC32</param>
+        /// <param name="output">The stream into which to deflate the input</param>
+        /// <returns>the CRC32 calculation</returns>
+        public Int32 GetCrc32AndCopy(System.IO.Stream input, System.IO.Stream output)
+        {
+            if (input == null)
+                throw new Exception("The input stream must not be null.");
+
+            unchecked
+            {
+                byte[] buffer = new byte[BUFFER_SIZE];
+                int readSize = BUFFER_SIZE;
+
+                _TotalBytesRead = 0;
+                int count = input.Read(buffer, 0, readSize);
+                if (output != null) output.Write(buffer, 0, count);
+                _TotalBytesRead += count;
+                while (count > 0)
+                {
+                    SlurpBlock(buffer, 0, count);
+                    count = input.Read(buffer, 0, readSize);
+                    if (output != null) output.Write(buffer, 0, count);
+                    _TotalBytesRead += count;
+                }
+
+                return (Int32)(~_register);
+            }
+        }
+
+
+        /// <summary>
+        ///   Get the CRC32 for the given (word,byte) combo.  This is a
+        ///   computation defined by PKzip for PKZIP 2.0 (weak) encryption.
+        /// </summary>
+        /// <param name="W">The word to start with.</param>
+        /// <param name="B">The byte to combine it with.</param>
+        /// <returns>The CRC-ized result.</returns>
+        public Int32 ComputeCrc32(Int32 W, byte B)
+        {
+            return _InternalComputeCrc32((UInt32)W, B);
+        }
+
+        internal Int32 _InternalComputeCrc32(UInt32 W, byte B)
+        {
+            return (Int32)(crc32Table[(W ^ B) & 0xFF] ^ (W >> 8));
+        }
+
+
+        /// <summary>
+        /// Update the value for the running CRC32 using the given block of bytes.
+        /// This is useful when using the CRC32() class in a Stream.
+        /// </summary>
+        /// <param name="block">block of bytes to slurp</param>
+        /// <param name="offset">starting point in the block</param>
+        /// <param name="count">how many bytes within the block to slurp</param>
+        public void SlurpBlock(byte[] block, int offset, int count)
+        {
+            if (block == null)
+                throw new Exception("The data buffer must not be null.");
+
+            // bzip algorithm
+            for (int i = 0; i < count; i++)
+            {
+                int x = offset + i;
+                byte b = block[x];
+                if (this.reverseBits)
+                {
+                    UInt32 temp = (_register >> 24) ^ b;
+                    _register = (_register << 8) ^ crc32Table[temp];
+                }
+                else
+                {
+                    UInt32 temp = (_register & 0x000000FF) ^ b;
+                    _register = (_register >> 8) ^ crc32Table[temp];
+                }
+            }
+            _TotalBytesRead += count;
+        }
+
+
+        /// <summary>
+        ///   Process one byte in the CRC.
+        /// </summary>
+        /// <param name = "b">the byte to include into the CRC .  </param>
+        public void UpdateCRC(byte b)
+        {
+            if (this.reverseBits)
+            {
+                UInt32 temp = (_register >> 24) ^ b;
+                _register = (_register << 8) ^ crc32Table[temp];
+            }
+            else
+            {
+                UInt32 temp = (_register & 0x000000FF) ^ b;
+                _register = (_register >> 8) ^ crc32Table[temp];
+            }
+        }
+
+        /// <summary>
+        ///   Process a run of N identical bytes into the CRC.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     This method serves as an optimization for updating the CRC when a
+        ///     run of identical bytes is found. Rather than passing in a buffer of
+        ///     length n, containing all identical bytes b, this method accepts the
+        ///     byte value and the length of the (virtual) buffer - the length of
+        ///     the run.
+        ///   </para>
+        /// </remarks>
+        /// <param name = "b">the byte to include into the CRC.  </param>
+        /// <param name = "n">the number of times that byte should be repeated. </param>
+        public void UpdateCRC(byte b, int n)
+        {
+            while (n-- > 0)
+            {
+                if (this.reverseBits)
+                {
+                    uint temp = (_register >> 24) ^ b;
+                    _register = (_register << 8) ^ crc32Table[(temp >= 0)
+                                                              ? temp
+                                                              : (temp + 256)];
+                }
+                else
+                {
+                    UInt32 temp = (_register & 0x000000FF) ^ b;
+                    _register = (_register >> 8) ^ crc32Table[(temp >= 0)
+                                                              ? temp
+                                                              : (temp + 256)];
+
+                }
+            }
+        }
+
+
+
+        private static uint ReverseBits(uint data)
+        {
+            unchecked
+            {
+                uint ret = data;
+                ret = (ret & 0x55555555) << 1 | (ret >> 1) & 0x55555555;
+                ret = (ret & 0x33333333) << 2 | (ret >> 2) & 0x33333333;
+                ret = (ret & 0x0F0F0F0F) << 4 | (ret >> 4) & 0x0F0F0F0F;
+                ret = (ret << 24) | ((ret & 0xFF00) << 8) | ((ret >> 8) & 0xFF00) | (ret >> 24);
+                return ret;
+            }
+        }
+
+        private static byte ReverseBits(byte data)
+        {
+            unchecked
+            {
+                uint u = (uint)data * 0x00020202;
+                uint m = 0x01044010;
+                uint s = u & m;
+                uint t = (u << 2) & (m << 1);
+                return (byte)((0x01001001 * (s + t)) >> 24);
+            }
+        }
+
+
+
+        private void GenerateLookupTable()
+        {
+            crc32Table = new UInt32[256];
+            unchecked
+            {
+                UInt32 dwCrc;
+                byte i = 0;
+                do
+                {
+                    dwCrc = i;
+                    for (byte j = 8; j > 0; j--)
+                    {
+                        if ((dwCrc & 1) == 1)
+                        {
+                            dwCrc = (dwCrc >> 1) ^ dwPolynomial;
+                        }
+                        else
+                        {
+                            dwCrc >>= 1;
+                        }
+                    }
+                    if (reverseBits)
+                    {
+                        crc32Table[ReverseBits(i)] = ReverseBits(dwCrc);
+                    }
+                    else
+                    {
+                        crc32Table[i] = dwCrc;
+                    }
+                    i++;
+                } while (i!=0);
+            }
+
+#if VERBOSE
+            Console.WriteLine();
+            Console.WriteLine("private static readonly UInt32[] crc32Table = {");
+            for (int i = 0; i < crc32Table.Length; i+=4)
+            {
+                Console.Write("   ");
+                for (int j=0; j < 4; j++)
+                {
+                    Console.Write(" 0x{0:X8}U,", crc32Table[i+j]);
+                }
+                Console.WriteLine();
+            }
+            Console.WriteLine("};");
+            Console.WriteLine();
+#endif
+        }
+
+
+        private uint gf2_matrix_times(uint[] matrix, uint vec)
+        {
+            uint sum = 0;
+            int i=0;
+            while (vec != 0)
+            {
+                if ((vec & 0x01)== 0x01)
+                    sum ^= matrix[i];
+                vec >>= 1;
+                i++;
+            }
+            return sum;
+        }
+
+        private void gf2_matrix_square(uint[] square, uint[] mat)
+        {
+            for (int i = 0; i < 32; i++)
+                square[i] = gf2_matrix_times(mat, mat[i]);
+        }
+
+
+
+        /// <summary>
+        ///   Combines the given CRC32 value with the current running total.
+        /// </summary>
+        /// <remarks>
+        ///   This is useful when using a divide-and-conquer approach to
+        ///   calculating a CRC.  Multiple threads can each calculate a
+        ///   CRC32 on a segment of the data, and then combine the
+        ///   individual CRC32 values at the end.
+        /// </remarks>
+        /// <param name="crc">the crc value to be combined with this one</param>
+        /// <param name="length">the length of data the CRC value was calculated on</param>
+        public void Combine(int crc, int length)
+        {
+            uint[] even = new uint[32];     // even-power-of-two zeros operator
+            uint[] odd = new uint[32];      // odd-power-of-two zeros operator
+
+            if (length == 0)
+                return;
+
+            uint crc1= ~_register;
+            uint crc2= (uint) crc;
+
+            // put operator for one zero bit in odd
+            odd[0] = this.dwPolynomial;  // the CRC-32 polynomial
+            uint row = 1;
+            for (int i = 1; i < 32; i++)
+            {
+                odd[i] = row;
+                row <<= 1;
+            }
+
+            // put operator for two zero bits in even
+            gf2_matrix_square(even, odd);
+
+            // put operator for four zero bits in odd
+            gf2_matrix_square(odd, even);
+
+            uint len2 = (uint) length;
+
+            // apply len2 zeros to crc1 (first square will put the operator for one
+            // zero byte, eight zero bits, in even)
+            do {
+                // apply zeros operator for this bit of len2
+                gf2_matrix_square(even, odd);
+
+                if ((len2 & 1)== 1)
+                    crc1 = gf2_matrix_times(even, crc1);
+                len2 >>= 1;
+
+                if (len2 == 0)
+                    break;
+
+                // another iteration of the loop with odd and even swapped
+                gf2_matrix_square(odd, even);
+                if ((len2 & 1)==1)
+                    crc1 = gf2_matrix_times(odd, crc1);
+                len2 >>= 1;
+
+
+            } while (len2 != 0);
+
+            crc1 ^= crc2;
+
+            _register= ~crc1;
+
+            //return (int) crc1;
+            return;
+        }
+
+
+        /// <summary>
+        ///   Create an instance of the CRC32 class using the default settings: no
+        ///   bit reversal, and a polynomial of 0xEDB88320.
+        /// </summary>
+        public CRC32() : this(false)
+        {
+        }
+
+        /// <summary>
+        ///   Create an instance of the CRC32 class, specifying whether to reverse
+        ///   data bits or not.
+        /// </summary>
+        /// <param name='reverseBits'>
+        ///   specify true if the instance should reverse data bits.
+        /// </param>
+        /// <remarks>
+        ///   <para>
+        ///     In the CRC-32 used by BZip2, the bits are reversed. Therefore if you
+        ///     want a CRC32 with compatibility with BZip2, you should pass true
+        ///     here. In the CRC-32 used by GZIP and PKZIP, the bits are not
+        ///     reversed; Therefore if you want a CRC32 with compatibility with
+        ///     those, you should pass false.
+        ///   </para>
+        /// </remarks>
+        public CRC32(bool reverseBits) :
+            this( unchecked((int)0xEDB88320), reverseBits)
+        {
+        }
+
+
+        /// <summary>
+        ///   Create an instance of the CRC32 class, specifying the polynomial and
+        ///   whether to reverse data bits or not.
+        /// </summary>
+        /// <param name='polynomial'>
+        ///   The polynomial to use for the CRC, expressed in the reversed (LSB)
+        ///   format: the highest ordered bit in the polynomial value is the
+        ///   coefficient of the 0th power; the second-highest order bit is the
+        ///   coefficient of the 1 power, and so on. Expressed this way, the
+        ///   polynomial for the CRC-32C used in IEEE 802.3, is 0xEDB88320.
+        /// </param>
+        /// <param name='reverseBits'>
+        ///   specify true if the instance should reverse data bits.
+        /// </param>
+        ///
+        /// <remarks>
+        ///   <para>
+        ///     In the CRC-32 used by BZip2, the bits are reversed. Therefore if you
+        ///     want a CRC32 with compatibility with BZip2, you should pass true
+        ///     here for the <c>reverseBits</c> parameter. In the CRC-32 used by
+        ///     GZIP and PKZIP, the bits are not reversed; Therefore if you want a
+        ///     CRC32 with compatibility with those, you should pass false for the
+        ///     <c>reverseBits</c> parameter.
+        ///   </para>
+        /// </remarks>
+        public CRC32(int polynomial, bool reverseBits)
+        {
+            this.reverseBits = reverseBits;
+            this.dwPolynomial = (uint) polynomial;
+            this.GenerateLookupTable();
+        }
+
+        /// <summary>
+        ///   Reset the CRC-32 class - clear the CRC "remainder register."
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     Use this when employing a single instance of this class to compute
+        ///     multiple, distinct CRCs on multiple, distinct data blocks.
+        ///   </para>
+        /// </remarks>
+        public void Reset()
+        {
+            _register = 0xFFFFFFFFU;
+        }
+
+        // private member vars
+        private UInt32 dwPolynomial;
+        private Int64 _TotalBytesRead;
+        private bool reverseBits;
+        private UInt32[] crc32Table;
+        private const int BUFFER_SIZE = 8192;
+        private UInt32 _register = 0xFFFFFFFFU;
+    }
+
+
+    /// <summary>
+    /// A Stream that calculates a CRC32 (a checksum) on all bytes read,
+    /// or on all bytes written.
+    /// </summary>
+    ///
+    /// <remarks>
+    /// <para>
+    /// This class can be used to verify the CRC of a ZipEntry when
+    /// reading from a stream, or to calculate a CRC when writing to a
+    /// stream.  The stream should be used to either read, or write, but
+    /// not both.  If you intermix reads and writes, the results are not
+    /// defined.
+    /// </para>
+    ///
+    /// <para>
+    /// This class is intended primarily for use internally by the
+    /// DotNetZip library.
+    /// </para>
+    /// </remarks>
+    public class CrcCalculatorStream : System.IO.Stream, System.IDisposable
+    {
+        private static readonly Int64 UnsetLengthLimit = -99;
+
+        internal System.IO.Stream _innerStream;
+        private CRC32 _Crc32;
+        private Int64 _lengthLimit = -99;
+        private bool _leaveOpen;
+
+        /// <summary>
+        /// The default constructor.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     Instances returned from this constructor will leave the underlying
+        ///     stream open upon Close().  The stream uses the default CRC32
+        ///     algorithm, which implies a polynomial of 0xEDB88320.
+        ///   </para>
+        /// </remarks>
+        /// <param name="stream">The underlying stream</param>
+        public CrcCalculatorStream(System.IO.Stream stream)
+            : this(true, CrcCalculatorStream.UnsetLengthLimit, stream, null)
+        {
+        }
+
+        /// <summary>
+        ///   The constructor allows the caller to specify how to handle the
+        ///   underlying stream at close.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     The stream uses the default CRC32 algorithm, which implies a
+        ///     polynomial of 0xEDB88320.
+        ///   </para>
+        /// </remarks>
+        /// <param name="stream">The underlying stream</param>
+        /// <param name="leaveOpen">true to leave the underlying stream
+        /// open upon close of the <c>CrcCalculatorStream</c>; false otherwise.</param>
+        public CrcCalculatorStream(System.IO.Stream stream, bool leaveOpen)
+            : this(leaveOpen, CrcCalculatorStream.UnsetLengthLimit, stream, null)
+        {
+        }
+
+        /// <summary>
+        ///   A constructor allowing the specification of the length of the stream
+        ///   to read.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     The stream uses the default CRC32 algorithm, which implies a
+        ///     polynomial of 0xEDB88320.
+        ///   </para>
+        ///   <para>
+        ///     Instances returned from this constructor will leave the underlying
+        ///     stream open upon Close().
+        ///   </para>
+        /// </remarks>
+        /// <param name="stream">The underlying stream</param>
+        /// <param name="length">The length of the stream to slurp</param>
+        public CrcCalculatorStream(System.IO.Stream stream, Int64 length)
+            : this(true, length, stream, null)
+        {
+            if (length < 0)
+                throw new ArgumentException("length");
+        }
+
+        /// <summary>
+        ///   A constructor allowing the specification of the length of the stream
+        ///   to read, as well as whether to keep the underlying stream open upon
+        ///   Close().
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     The stream uses the default CRC32 algorithm, which implies a
+        ///     polynomial of 0xEDB88320.
+        ///   </para>
+        /// </remarks>
+        /// <param name="stream">The underlying stream</param>
+        /// <param name="length">The length of the stream to slurp</param>
+        /// <param name="leaveOpen">true to leave the underlying stream
+        /// open upon close of the <c>CrcCalculatorStream</c>; false otherwise.</param>
+        public CrcCalculatorStream(System.IO.Stream stream, Int64 length, bool leaveOpen)
+            : this(leaveOpen, length, stream, null)
+        {
+            if (length < 0)
+                throw new ArgumentException("length");
+        }
+
+        /// <summary>
+        ///   A constructor allowing the specification of the length of the stream
+        ///   to read, as well as whether to keep the underlying stream open upon
+        ///   Close(), and the CRC32 instance to use.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     The stream uses the specified CRC32 instance, which allows the
+        ///     application to specify how the CRC gets calculated.
+        ///   </para>
+        /// </remarks>
+        /// <param name="stream">The underlying stream</param>
+        /// <param name="length">The length of the stream to slurp</param>
+        /// <param name="leaveOpen">true to leave the underlying stream
+        /// open upon close of the <c>CrcCalculatorStream</c>; false otherwise.</param>
+        /// <param name="crc32">the CRC32 instance to use to calculate the CRC32</param>
+        public CrcCalculatorStream(System.IO.Stream stream, Int64 length, bool leaveOpen,
+                                   CRC32 crc32)
+            : this(leaveOpen, length, stream, crc32)
+        {
+            if (length < 0)
+                throw new ArgumentException("length");
+        }
+
+
+        // This ctor is private - no validation is done here.  This is to allow the use
+        // of a (specific) negative value for the _lengthLimit, to indicate that there
+        // is no length set.  So we validate the length limit in those ctors that use an
+        // explicit param, otherwise we don't validate, because it could be our special
+        // value.
+        private CrcCalculatorStream
+            (bool leaveOpen, Int64 length, System.IO.Stream stream, CRC32 crc32)
+            : base()
+        {
+            _innerStream = stream;
+            _Crc32 = crc32 ?? new CRC32();
+            _lengthLimit = length;
+            _leaveOpen = leaveOpen;
+        }
+
+
+        /// <summary>
+        ///   Gets the total number of bytes run through the CRC32 calculator.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   This is either the total number of bytes read, or the total number of
+        ///   bytes written, depending on the direction of this stream.
+        /// </remarks>
+        public Int64 TotalBytesSlurped
+        {
+            get { return _Crc32.TotalBytesRead; }
+        }
+
+        /// <summary>
+        ///   Provides the current CRC for all blocks slurped in.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     The running total of the CRC is kept as data is written or read
+        ///     through the stream.  read this property after all reads or writes to
+        ///     get an accurate CRC for the entire stream.
+        ///   </para>
+        /// </remarks>
+        public Int32 Crc
+        {
+            get { return _Crc32.Crc32Result; }
+        }
+
+        /// <summary>
+        ///   Indicates whether the underlying stream will be left open when the
+        ///   <c>CrcCalculatorStream</c> is Closed.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     Set this at any point before calling <see cref="Close()"/>.
+        ///   </para>
+        /// </remarks>
+        public bool LeaveOpen
+        {
+            get { return _leaveOpen; }
+            set { _leaveOpen = value; }
+        }
+
+        /// <summary>
+        /// Read from the stream
+        /// </summary>
+        /// <param name="buffer">the buffer to read</param>
+        /// <param name="offset">the offset at which to start</param>
+        /// <param name="count">the number of bytes to read</param>
+        /// <returns>the number of bytes actually read</returns>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            int bytesToRead = count;
+
+            // Need to limit the # of bytes returned, if the stream is intended to have
+            // a definite length.  This is especially useful when returning a stream for
+            // the uncompressed data directly to the application.  The app won't
+            // necessarily read only the UncompressedSize number of bytes.  For example
+            // wrapping the stream returned from OpenReader() into a StreadReader() and
+            // calling ReadToEnd() on it, We can "over-read" the zip data and get a
+            // corrupt string.  The length limits that, prevents that problem.
+
+            if (_lengthLimit != CrcCalculatorStream.UnsetLengthLimit)
+            {
+                if (_Crc32.TotalBytesRead >= _lengthLimit) return 0; // EOF
+                Int64 bytesRemaining = _lengthLimit - _Crc32.TotalBytesRead;
+                if (bytesRemaining < count) bytesToRead = (int)bytesRemaining;
+            }
+            int n = _innerStream.Read(buffer, offset, bytesToRead);
+            if (n > 0) _Crc32.SlurpBlock(buffer, offset, n);
+            return n;
+        }
+
+        /// <summary>
+        /// Write to the stream.
+        /// </summary>
+        /// <param name="buffer">the buffer from which to write</param>
+        /// <param name="offset">the offset at which to start writing</param>
+        /// <param name="count">the number of bytes to write</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (count > 0) _Crc32.SlurpBlock(buffer, offset, count);
+            _innerStream.Write(buffer, offset, count);
+        }
+
+        /// <summary>
+        /// Indicates whether the stream supports reading.
+        /// </summary>
+        public override bool CanRead
+        {
+            get { return _innerStream.CanRead; }
+        }
+
+        /// <summary>
+        ///   Indicates whether the stream supports seeking.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     Always returns false.
+        ///   </para>
+        /// </remarks>
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// Indicates whether the stream supports writing.
+        /// </summary>
+        public override bool CanWrite
+        {
+            get { return _innerStream.CanWrite; }
+        }
+
+        /// <summary>
+        /// Flush the stream.
+        /// </summary>
+        public override void Flush()
+        {
+            _innerStream.Flush();
+        }
+
+        /// <summary>
+        ///   Returns the length of the underlying stream.
+        /// </summary>
+        public override long Length
+        {
+            get
+            {
+                if (_lengthLimit == CrcCalculatorStream.UnsetLengthLimit)
+                    return _innerStream.Length;
+                else return _lengthLimit;
+            }
+        }
+
+        /// <summary>
+        ///   The getter for this property returns the total bytes read.
+        ///   If you use the setter, it will throw
+        /// <see cref="NotSupportedException"/>.
+        /// </summary>
+        public override long Position
+        {
+            get { return _Crc32.TotalBytesRead; }
+            set { throw new NotSupportedException(); }
+        }
+
+        /// <summary>
+        /// Seeking is not supported on this stream. This method always throws
+        /// <see cref="NotSupportedException"/>
+        /// </summary>
+        /// <param name="offset">N/A</param>
+        /// <param name="origin">N/A</param>
+        /// <returns>N/A</returns>
+        public override long Seek(long offset, System.IO.SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// This method always throws
+        /// <see cref="NotSupportedException"/>
+        /// </summary>
+        /// <param name="value">N/A</param>
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+
+        void IDisposable.Dispose()
+        {
+            Close();
+        }
+
+        /// <summary>
+        /// Closes the stream.
+        /// </summary>
+        public override void Close()
+        {
+            base.Close();
+            if (!_leaveOpen)
+                _innerStream.Close();
+        }
+
+    }
+
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Deflate/Deflate.cs b/MonoGame.Framework/Utilities/Deflate/Deflate.cs
new file mode 100644
index 00000000000..7599b845165
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Deflate/Deflate.cs
@@ -0,0 +1,1879 @@
+// Deflate.cs
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
+// All rights reserved.
+//
+// This code module is part of DotNetZip, a zipfile class library.
+//
+// ------------------------------------------------------------------
+//
+// This code is licensed under the Microsoft Public License.
+// See the file License.txt for the license details.
+// More info on: http://dotnetzip.codeplex.com
+//
+// ------------------------------------------------------------------
+//
+// last saved (in emacs):
+// Time-stamp: <2011-August-03 19:52:15>
+//
+// ------------------------------------------------------------------
+//
+// This module defines logic for handling the Deflate or compression.
+//
+// This code is based on multiple sources:
+// - the original zlib v1.2.3 source, which is Copyright (C) 1995-2005 Jean-loup Gailly.
+// - the original jzlib, which is Copyright (c) 2000-2003 ymnk, JCraft,Inc.
+//
+// However, this code is significantly different from both.
+// The object model is not the same, and many of the behaviors are different.
+//
+// In keeping with the license for these other works, the copyrights for
+// jzlib and zlib are here.
+//
+// -----------------------------------------------------------------------
+// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in
+// the documentation and/or other materials provided with the distribution.
+//
+// 3. The names of the authors may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// -----------------------------------------------------------------------
+//
+// This program is based on zlib-1.1.3; credit to authors
+// Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+// and contributors of zlib.
+//
+// -----------------------------------------------------------------------
+
+
+using System;
+
+namespace MonoGame.Utilities.Deflate
+{
+
+    internal enum BlockState
+    {
+        NeedMore = 0,       // block not completed, need more input or more output
+        BlockDone,          // block flush performed
+        FinishStarted,              // finish started, need only more output at next deflate
+        FinishDone          // finish done, accept no more input or output
+    }
+
+    internal enum DeflateFlavor
+    {
+        Store,
+        Fast,
+        Slow
+    }
+
+    internal sealed class DeflateManager
+    {
+        private static readonly int MEM_LEVEL_MAX = 9;
+        private static readonly int MEM_LEVEL_DEFAULT = 8;
+
+        internal delegate BlockState CompressFunc(FlushType flush);
+
+        internal class Config
+        {
+            // Use a faster search when the previous match is longer than this
+            internal int GoodLength; // reduce lazy search above this match length
+
+            // Attempt to find a better match only when the current match is
+            // strictly smaller than this value. This mechanism is used only for
+            // compression levels >= 4.  For levels 1,2,3: MaxLazy is actually
+            // MaxInsertLength. (See DeflateFast)
+
+            internal int MaxLazy;    // do not perform lazy search above this match length
+
+            internal int NiceLength; // quit search above this match length
+
+            // To speed up deflation, hash chains are never searched beyond this
+            // length.  A higher limit improves compression ratio but degrades the speed.
+
+            internal int MaxChainLength;
+
+            internal DeflateFlavor Flavor;
+
+            private Config(int goodLength, int maxLazy, int niceLength, int maxChainLength, DeflateFlavor flavor)
+            {
+                this.GoodLength = goodLength;
+                this.MaxLazy = maxLazy;
+                this.NiceLength = niceLength;
+                this.MaxChainLength = maxChainLength;
+                this.Flavor = flavor;
+            }
+
+            public static Config Lookup(CompressionLevel level)
+            {
+                return Table[(int)level];
+            }
+
+
+            static Config()
+            {
+                Table = new Config[] {
+                    new Config(0, 0, 0, 0, DeflateFlavor.Store),
+                    new Config(4, 4, 8, 4, DeflateFlavor.Fast),
+                    new Config(4, 5, 16, 8, DeflateFlavor.Fast),
+                    new Config(4, 6, 32, 32, DeflateFlavor.Fast),
+
+                    new Config(4, 4, 16, 16, DeflateFlavor.Slow),
+                    new Config(8, 16, 32, 32, DeflateFlavor.Slow),
+                    new Config(8, 16, 128, 128, DeflateFlavor.Slow),
+                    new Config(8, 32, 128, 256, DeflateFlavor.Slow),
+                    new Config(32, 128, 258, 1024, DeflateFlavor.Slow),
+                    new Config(32, 258, 258, 4096, DeflateFlavor.Slow),
+                };
+            }
+
+            private static readonly Config[] Table;
+        }
+
+
+        private CompressFunc DeflateFunction;
+
+        private static readonly System.String[] _ErrorMessage = new System.String[]
+        {
+            "need dictionary",
+            "stream end",
+            "",
+            "file error",
+            "stream error",
+            "data error",
+            "insufficient memory",
+            "buffer error",
+            "incompatible version",
+            ""
+        };
+
+        // preset dictionary flag in zlib header
+        private static readonly int PRESET_DICT = 0x20;
+
+        private static readonly int INIT_STATE = 42;
+        private static readonly int BUSY_STATE = 113;
+        private static readonly int FINISH_STATE = 666;
+
+        // The deflate compression method
+        private static readonly int Z_DEFLATED = 8;
+
+        private static readonly int STORED_BLOCK = 0;
+        private static readonly int STATIC_TREES = 1;
+        private static readonly int DYN_TREES = 2;
+
+        // The three kinds of block type
+        private static readonly int Z_BINARY = 0;
+        private static readonly int Z_ASCII = 1;
+        private static readonly int Z_UNKNOWN = 2;
+
+        private static readonly int Buf_size = 8 * 2;
+
+        private static readonly int MIN_MATCH = 3;
+        private static readonly int MAX_MATCH = 258;
+
+        private static readonly int MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1);
+
+        private static readonly int HEAP_SIZE = (2 * InternalConstants.L_CODES + 1);
+
+        private static readonly int END_BLOCK = 256;
+
+        internal ZlibCodec _codec; // the zlib encoder/decoder
+        internal int status;       // as the name implies
+        internal byte[] pending;   // output still pending - waiting to be compressed
+        internal int nextPending;  // index of next pending byte to output to the stream
+        internal int pendingCount; // number of bytes in the pending buffer
+
+        internal sbyte data_type;  // UNKNOWN, BINARY or ASCII
+        internal int last_flush;   // value of flush param for previous deflate call
+
+        internal int w_size;       // LZ77 window size (32K by default)
+        internal int w_bits;       // log2(w_size)  (8..16)
+        internal int w_mask;       // w_size - 1
+
+        //internal byte[] dictionary;
+        internal byte[] window;
+
+        // Sliding window. Input bytes are read into the second half of the window,
+        // and move to the first half later to keep a dictionary of at least wSize
+        // bytes. With this organization, matches are limited to a distance of
+        // wSize-MAX_MATCH bytes, but this ensures that IO is always
+        // performed with a length multiple of the block size.
+        //
+        // To do: use the user input buffer as sliding window.
+
+        internal int window_size;
+        // Actual size of window: 2*wSize, except when the user input buffer
+        // is directly used as sliding window.
+
+        internal short[] prev;
+        // Link to older string with same hash index. To limit the size of this
+        // array to 64K, this link is maintained only for the last 32K strings.
+        // An index in this array is thus a window index modulo 32K.
+
+        internal short[] head;  // Heads of the hash chains or NIL.
+
+        internal int ins_h;     // hash index of string to be inserted
+        internal int hash_size; // number of elements in hash table
+        internal int hash_bits; // log2(hash_size)
+        internal int hash_mask; // hash_size-1
+
+        // Number of bits by which ins_h must be shifted at each input
+        // step. It must be such that after MIN_MATCH steps, the oldest
+        // byte no longer takes part in the hash key, that is:
+        // hash_shift * MIN_MATCH >= hash_bits
+        internal int hash_shift;
+
+        // Window position at the beginning of the current output block. Gets
+        // negative when the window is moved backwards.
+
+        internal int block_start;
+
+        Config config;
+        internal int match_length;    // length of best match
+        internal int prev_match;      // previous match
+        internal int match_available; // set if previous match exists
+        internal int strstart;        // start of string to insert into.....????
+        internal int match_start;     // start of matching string
+        internal int lookahead;       // number of valid bytes ahead in window
+
+        // Length of the best match at previous step. Matches not greater than this
+        // are discarded. This is used in the lazy match evaluation.
+        internal int prev_length;
+
+        // Insert new strings in the hash table only if the match length is not
+        // greater than this length. This saves time but degrades compression.
+        // max_insert_length is used only for compression levels <= 3.
+
+        internal CompressionLevel compressionLevel; // compression level (1..9)
+        internal CompressionStrategy compressionStrategy; // favor or force Huffman coding
+
+
+        internal short[] dyn_ltree;         // literal and length tree
+        internal short[] dyn_dtree;         // distance tree
+        internal short[] bl_tree;           // Huffman tree for bit lengths
+
+        internal Tree treeLiterals = new Tree();  // desc for literal tree
+        internal Tree treeDistances = new Tree();  // desc for distance tree
+        internal Tree treeBitLengths = new Tree(); // desc for bit length tree
+
+        // number of codes at each bit length for an optimal tree
+        internal short[] bl_count = new short[InternalConstants.MAX_BITS + 1];
+
+        // heap used to build the Huffman trees
+        internal int[] heap = new int[2 * InternalConstants.L_CODES + 1];
+
+        internal int heap_len;              // number of elements in the heap
+        internal int heap_max;              // element of largest frequency
+
+        // The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+        // The same heap array is used to build all trees.
+
+        // Depth of each subtree used as tie breaker for trees of equal frequency
+        internal sbyte[] depth = new sbyte[2 * InternalConstants.L_CODES + 1];
+
+        internal int _lengthOffset;                 // index for literals or lengths
+
+
+        // Size of match buffer for literals/lengths.  There are 4 reasons for
+        // limiting lit_bufsize to 64K:
+        //   - frequencies can be kept in 16 bit counters
+        //   - if compression is not successful for the first block, all input
+        //     data is still in the window so we can still emit a stored block even
+        //     when input comes from standard input.  (This can also be done for
+        //     all blocks if lit_bufsize is not greater than 32K.)
+        //   - if compression is not successful for a file smaller than 64K, we can
+        //     even emit a stored file instead of a stored block (saving 5 bytes).
+        //     This is applicable only for zip (not gzip or zlib).
+        //   - creating new Huffman trees less frequently may not provide fast
+        //     adaptation to changes in the input data statistics. (Take for
+        //     example a binary file with poorly compressible code followed by
+        //     a highly compressible string table.) Smaller buffer sizes give
+        //     fast adaptation but have of course the overhead of transmitting
+        //     trees more frequently.
+
+        internal int lit_bufsize;
+
+        internal int last_lit;     // running index in l_buf
+
+        // Buffer for distances. To simplify the code, d_buf and l_buf have
+        // the same number of elements. To use different lengths, an extra flag
+        // array would be necessary.
+
+        internal int _distanceOffset;        // index into pending; points to distance data??
+
+        internal int opt_len;      // bit length of current block with optimal trees
+        internal int static_len;   // bit length of current block with static trees
+        internal int matches;      // number of string matches in current block
+        internal int last_eob_len; // bit length of EOB code for last block
+
+        // Output buffer. bits are inserted starting at the bottom (least
+        // significant bits).
+        internal short bi_buf;
+
+        // Number of valid bits in bi_buf.  All bits above the last valid bit
+        // are always zero.
+        internal int bi_valid;
+
+
+        internal DeflateManager()
+        {
+            dyn_ltree = new short[HEAP_SIZE * 2];
+            dyn_dtree = new short[(2 * InternalConstants.D_CODES + 1) * 2]; // distance tree
+            bl_tree = new short[(2 * InternalConstants.BL_CODES + 1) * 2]; // Huffman tree for bit lengths
+        }
+
+
+        // lm_init
+        private void _InitializeLazyMatch()
+        {
+            window_size = 2 * w_size;
+
+            // clear the hash - workitem 9063
+            Array.Clear(head, 0, hash_size);
+            //for (int i = 0; i < hash_size; i++) head[i] = 0;
+
+            config = Config.Lookup(compressionLevel);
+            SetDeflater();
+
+            strstart = 0;
+            block_start = 0;
+            lookahead = 0;
+            match_length = prev_length = MIN_MATCH - 1;
+            match_available = 0;
+            ins_h = 0;
+        }
+
+        // Initialize the tree data structures for a new zlib stream.
+        private void _InitializeTreeData()
+        {
+            treeLiterals.dyn_tree = dyn_ltree;
+            treeLiterals.staticTree = StaticTree.Literals;
+
+            treeDistances.dyn_tree = dyn_dtree;
+            treeDistances.staticTree = StaticTree.Distances;
+
+            treeBitLengths.dyn_tree = bl_tree;
+            treeBitLengths.staticTree = StaticTree.BitLengths;
+
+            bi_buf = 0;
+            bi_valid = 0;
+            last_eob_len = 8; // enough lookahead for inflate
+
+            // Initialize the first block of the first file:
+            _InitializeBlocks();
+        }
+
+        internal void _InitializeBlocks()
+        {
+            // Initialize the trees.
+            for (int i = 0; i < InternalConstants.L_CODES; i++)
+                dyn_ltree[i * 2] = 0;
+            for (int i = 0; i < InternalConstants.D_CODES; i++)
+                dyn_dtree[i * 2] = 0;
+            for (int i = 0; i < InternalConstants.BL_CODES; i++)
+                bl_tree[i * 2] = 0;
+
+            dyn_ltree[END_BLOCK * 2] = 1;
+            opt_len = static_len = 0;
+            last_lit = matches = 0;
+        }
+
+        // Restore the heap property by moving down the tree starting at node k,
+        // exchanging a node with the smallest of its two sons if necessary, stopping
+        // when the heap property is re-established (each father smaller than its
+        // two sons).
+        internal void pqdownheap(short[] tree, int k)
+        {
+            int v = heap[k];
+            int j = k << 1; // left son of k
+            while (j <= heap_len)
+            {
+                // Set j to the smallest of the two sons:
+                if (j < heap_len && _IsSmaller(tree, heap[j + 1], heap[j], depth))
+                {
+                    j++;
+                }
+                // Exit if v is smaller than both sons
+                if (_IsSmaller(tree, v, heap[j], depth))
+                    break;
+
+                // Exchange v with the smallest son
+                heap[k] = heap[j]; k = j;
+                // And continue down the tree, setting j to the left son of k
+                j <<= 1;
+            }
+            heap[k] = v;
+        }
+
+        internal static bool _IsSmaller(short[] tree, int n, int m, sbyte[] depth)
+        {
+            short tn2 = tree[n * 2];
+            short tm2 = tree[m * 2];
+            return (tn2 < tm2 || (tn2 == tm2 && depth[n] <= depth[m]));
+        }
+
+
+        // Scan a literal or distance tree to determine the frequencies of the codes
+        // in the bit length tree.
+        internal void scan_tree(short[] tree, int max_code)
+        {
+            int n; // iterates over all tree elements
+            int prevlen = -1; // last emitted length
+            int curlen; // length of current code
+            int nextlen = (int)tree[0 * 2 + 1]; // length of next code
+            int count = 0; // repeat count of the current code
+            int max_count = 7; // max repeat count
+            int min_count = 4; // min repeat count
+
+            if (nextlen == 0)
+            {
+                max_count = 138; min_count = 3;
+            }
+            tree[(max_code + 1) * 2 + 1] = (short)0x7fff; // guard //??
+
+            for (n = 0; n <= max_code; n++)
+            {
+                curlen = nextlen; nextlen = (int)tree[(n + 1) * 2 + 1];
+                if (++count < max_count && curlen == nextlen)
+                {
+                    continue;
+                }
+                else if (count < min_count)
+                {
+                    bl_tree[curlen * 2] = (short)(bl_tree[curlen * 2] + count);
+                }
+                else if (curlen != 0)
+                {
+                    if (curlen != prevlen)
+                        bl_tree[curlen * 2]++;
+                    bl_tree[InternalConstants.REP_3_6 * 2]++;
+                }
+                else if (count <= 10)
+                {
+                    bl_tree[InternalConstants.REPZ_3_10 * 2]++;
+                }
+                else
+                {
+                    bl_tree[InternalConstants.REPZ_11_138 * 2]++;
+                }
+                count = 0; prevlen = curlen;
+                if (nextlen == 0)
+                {
+                    max_count = 138; min_count = 3;
+                }
+                else if (curlen == nextlen)
+                {
+                    max_count = 6; min_count = 3;
+                }
+                else
+                {
+                    max_count = 7; min_count = 4;
+                }
+            }
+        }
+
+        // Construct the Huffman tree for the bit lengths and return the index in
+        // bl_order of the last bit length code to send.
+        internal int build_bl_tree()
+        {
+            int max_blindex; // index of last bit length code of non zero freq
+
+            // Determine the bit length frequencies for literal and distance trees
+            scan_tree(dyn_ltree, treeLiterals.max_code);
+            scan_tree(dyn_dtree, treeDistances.max_code);
+
+            // Build the bit length tree:
+            treeBitLengths.build_tree(this);
+            // opt_len now includes the length of the tree representations, except
+            // the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
+
+            // Determine the number of bit length codes to send. The pkzip format
+            // requires that at least 4 bit length codes be sent. (appnote.txt says
+            // 3 but the actual value used is 4.)
+            for (max_blindex = InternalConstants.BL_CODES - 1; max_blindex >= 3; max_blindex--)
+            {
+                if (bl_tree[Tree.bl_order[max_blindex] * 2 + 1] != 0)
+                    break;
+            }
+            // Update opt_len to include the bit length tree and counts
+            opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
+
+            return max_blindex;
+        }
+
+
+        // Send the header for a block using dynamic Huffman trees: the counts, the
+        // lengths of the bit length codes, the literal tree and the distance tree.
+        // IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+        internal void send_all_trees(int lcodes, int dcodes, int blcodes)
+        {
+            int rank; // index in bl_order
+
+            send_bits(lcodes - 257, 5); // not +255 as stated in appnote.txt
+            send_bits(dcodes - 1, 5);
+            send_bits(blcodes - 4, 4); // not -3 as stated in appnote.txt
+            for (rank = 0; rank < blcodes; rank++)
+            {
+                send_bits(bl_tree[Tree.bl_order[rank] * 2 + 1], 3);
+            }
+            send_tree(dyn_ltree, lcodes - 1); // literal tree
+            send_tree(dyn_dtree, dcodes - 1); // distance tree
+        }
+
+        // Send a literal or distance tree in compressed form, using the codes in
+        // bl_tree.
+        internal void send_tree(short[] tree, int max_code)
+        {
+            int n;                           // iterates over all tree elements
+            int prevlen   = -1;              // last emitted length
+            int curlen;                      // length of current code
+            int nextlen   = tree[0 * 2 + 1]; // length of next code
+            int count     = 0;               // repeat count of the current code
+            int max_count = 7;               // max repeat count
+            int min_count = 4;               // min repeat count
+
+            if (nextlen == 0)
+            {
+                max_count = 138; min_count = 3;
+            }
+
+            for (n = 0; n <= max_code; n++)
+            {
+                curlen = nextlen; nextlen = tree[(n + 1) * 2 + 1];
+                if (++count < max_count && curlen == nextlen)
+                {
+                    continue;
+                }
+                else if (count < min_count)
+                {
+                    do
+                    {
+                        send_code(curlen, bl_tree);
+                    }
+                    while (--count != 0);
+                }
+                else if (curlen != 0)
+                {
+                    if (curlen != prevlen)
+                    {
+                        send_code(curlen, bl_tree); count--;
+                    }
+                    send_code(InternalConstants.REP_3_6, bl_tree);
+                    send_bits(count - 3, 2);
+                }
+                else if (count <= 10)
+                {
+                    send_code(InternalConstants.REPZ_3_10, bl_tree);
+                    send_bits(count - 3, 3);
+                }
+                else
+                {
+                    send_code(InternalConstants.REPZ_11_138, bl_tree);
+                    send_bits(count - 11, 7);
+                }
+                count = 0; prevlen = curlen;
+                if (nextlen == 0)
+                {
+                    max_count = 138; min_count = 3;
+                }
+                else if (curlen == nextlen)
+                {
+                    max_count = 6; min_count = 3;
+                }
+                else
+                {
+                    max_count = 7; min_count = 4;
+                }
+            }
+        }
+
+        // Output a block of bytes on the stream.
+        // IN assertion: there is enough room in pending_buf.
+        private void put_bytes(byte[] p, int start, int len)
+        {
+            Array.Copy(p, start, pending, pendingCount, len);
+            pendingCount += len;
+        }
+
+#if NOTNEEDED
+        private void put_byte(byte c)
+        {
+            pending[pendingCount++] = c;
+        }
+        internal void put_short(int b)
+        {
+            unchecked
+            {
+                pending[pendingCount++] = (byte)b;
+                pending[pendingCount++] = (byte)(b >> 8);
+            }
+        }
+        internal void putShortMSB(int b)
+        {
+            unchecked
+            {
+                pending[pendingCount++] = (byte)(b >> 8);
+                pending[pendingCount++] = (byte)b;
+            }
+        }
+#endif
+
+        internal void send_code(int c, short[] tree)
+        {
+            int c2 = c * 2;
+            send_bits((tree[c2] & 0xffff), (tree[c2 + 1] & 0xffff));
+        }
+
+        internal void send_bits(int value, int length)
+        {
+            int len = length;
+            unchecked
+            {
+                if (bi_valid > (int)Buf_size - len)
+                {
+                    //int val = value;
+                    //      bi_buf |= (val << bi_valid);
+
+                    bi_buf |= (short)((value << bi_valid) & 0xffff);
+                    //put_short(bi_buf);
+                        pending[pendingCount++] = (byte)bi_buf;
+                        pending[pendingCount++] = (byte)(bi_buf >> 8);
+
+
+                    bi_buf = (short)((uint)value >> (Buf_size - bi_valid));
+                    bi_valid += len - Buf_size;
+                }
+                else
+                {
+                    //      bi_buf |= (value) << bi_valid;
+                    bi_buf |= (short)((value << bi_valid) & 0xffff);
+                    bi_valid += len;
+                }
+            }
+        }
+
+        // Send one empty static block to give enough lookahead for inflate.
+        // This takes 10 bits, of which 7 may remain in the bit buffer.
+        // The current inflate code requires 9 bits of lookahead. If the
+        // last two codes for the previous block (real code plus EOB) were coded
+        // on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode
+        // the last real code. In this case we send two empty static blocks instead
+        // of one. (There are no problems if the previous block is stored or fixed.)
+        // To simplify the code, we assume the worst case of last real code encoded
+        // on one bit only.
+        internal void _tr_align()
+        {
+            send_bits(STATIC_TREES << 1, 3);
+            send_code(END_BLOCK, StaticTree.lengthAndLiteralsTreeCodes);
+
+            bi_flush();
+
+            // Of the 10 bits for the empty block, we have already sent
+            // (10 - bi_valid) bits. The lookahead for the last real code (before
+            // the EOB of the previous block) was thus at least one plus the length
+            // of the EOB plus what we have just sent of the empty static block.
+            if (1 + last_eob_len + 10 - bi_valid < 9)
+            {
+                send_bits(STATIC_TREES << 1, 3);
+                send_code(END_BLOCK, StaticTree.lengthAndLiteralsTreeCodes);
+                bi_flush();
+            }
+            last_eob_len = 7;
+        }
+
+
+        // Save the match info and tally the frequency counts. Return true if
+        // the current block must be flushed.
+        internal bool _tr_tally(int dist, int lc)
+        {
+            pending[_distanceOffset + last_lit * 2] = unchecked((byte) ( (uint)dist >> 8 ) );
+            pending[_distanceOffset + last_lit * 2 + 1] = unchecked((byte)dist);
+            pending[_lengthOffset + last_lit] = unchecked((byte)lc);
+            last_lit++;
+
+            if (dist == 0)
+            {
+                // lc is the unmatched char
+                dyn_ltree[lc * 2]++;
+            }
+            else
+            {
+                matches++;
+                // Here, lc is the match length - MIN_MATCH
+                dist--; // dist = match distance - 1
+                dyn_ltree[(Tree.LengthCode[lc] + InternalConstants.LITERALS + 1) * 2]++;
+                dyn_dtree[Tree.DistanceCode(dist) * 2]++;
+            }
+
+            if ((last_lit & 0x1fff) == 0 && (int)compressionLevel > 2)
+            {
+                // Compute an upper bound for the compressed length
+                int out_length = last_lit << 3;
+                int in_length = strstart - block_start;
+                int dcode;
+                for (dcode = 0; dcode < InternalConstants.D_CODES; dcode++)
+                {
+                    out_length = (int)(out_length + (int)dyn_dtree[dcode * 2] * (5L + Tree.ExtraDistanceBits[dcode]));
+                }
+                out_length >>= 3;
+                if ((matches < (last_lit / 2)) && out_length < in_length / 2)
+                    return true;
+            }
+
+            return (last_lit == lit_bufsize - 1) || (last_lit == lit_bufsize);
+            // dinoch - wraparound?
+            // We avoid equality with lit_bufsize because of wraparound at 64K
+            // on 16 bit machines and because stored blocks are restricted to
+            // 64K-1 bytes.
+        }
+
+
+
+        // Send the block data compressed using the given Huffman trees
+        internal void send_compressed_block(short[] ltree, short[] dtree)
+        {
+            int distance; // distance of matched string
+            int lc;       // match length or unmatched char (if dist == 0)
+            int lx = 0;   // running index in l_buf
+            int code;     // the code to send
+            int extra;    // number of extra bits to send
+
+            if (last_lit != 0)
+            {
+                do
+                {
+                    int ix = _distanceOffset + lx * 2;
+                    distance = ((pending[ix] << 8) & 0xff00) |
+                        (pending[ix + 1] & 0xff);
+                    lc = (pending[_lengthOffset + lx]) & 0xff;
+                    lx++;
+
+                    if (distance == 0)
+                    {
+                        send_code(lc, ltree); // send a literal byte
+                    }
+                    else
+                    {
+                        // literal or match pair
+                        // Here, lc is the match length - MIN_MATCH
+                        code = Tree.LengthCode[lc];
+
+                        // send the length code
+                        send_code(code + InternalConstants.LITERALS + 1, ltree);
+                        extra = Tree.ExtraLengthBits[code];
+                        if (extra != 0)
+                        {
+                            // send the extra length bits
+                            lc -= Tree.LengthBase[code];
+                            send_bits(lc, extra);
+                        }
+                        distance--; // dist is now the match distance - 1
+                        code = Tree.DistanceCode(distance);
+
+                        // send the distance code
+                        send_code(code, dtree);
+
+                        extra = Tree.ExtraDistanceBits[code];
+                        if (extra != 0)
+                        {
+                            // send the extra distance bits
+                            distance -= Tree.DistanceBase[code];
+                            send_bits(distance, extra);
+                        }
+                    }
+
+                    // Check that the overlay between pending and d_buf+l_buf is ok:
+                }
+                while (lx < last_lit);
+            }
+
+            send_code(END_BLOCK, ltree);
+            last_eob_len = ltree[END_BLOCK * 2 + 1];
+        }
+
+
+
+        // Set the data type to ASCII or BINARY, using a crude approximation:
+        // binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise.
+        // IN assertion: the fields freq of dyn_ltree are set and the total of all
+        // frequencies does not exceed 64K (to fit in an int on 16 bit machines).
+        internal void set_data_type()
+        {
+            int n = 0;
+            int ascii_freq = 0;
+            int bin_freq = 0;
+            while (n < 7)
+            {
+                bin_freq += dyn_ltree[n * 2]; n++;
+            }
+            while (n < 128)
+            {
+                ascii_freq += dyn_ltree[n * 2]; n++;
+            }
+            while (n < InternalConstants.LITERALS)
+            {
+                bin_freq += dyn_ltree[n * 2]; n++;
+            }
+            data_type = (sbyte)(bin_freq > (ascii_freq >> 2) ? Z_BINARY : Z_ASCII);
+        }
+
+
+
+        // Flush the bit buffer, keeping at most 7 bits in it.
+        internal void bi_flush()
+        {
+            if (bi_valid == 16)
+            {
+                pending[pendingCount++] = (byte)bi_buf;
+                pending[pendingCount++] = (byte)(bi_buf >> 8);
+                bi_buf = 0;
+                bi_valid = 0;
+            }
+            else if (bi_valid >= 8)
+            {
+                //put_byte((byte)bi_buf);
+                pending[pendingCount++] = (byte)bi_buf;
+                bi_buf >>= 8;
+                bi_valid -= 8;
+            }
+        }
+
+        // Flush the bit buffer and align the output on a byte boundary
+        internal void bi_windup()
+        {
+            if (bi_valid > 8)
+            {
+                pending[pendingCount++] = (byte)bi_buf;
+                pending[pendingCount++] = (byte)(bi_buf >> 8);
+            }
+            else if (bi_valid > 0)
+            {
+                //put_byte((byte)bi_buf);
+                pending[pendingCount++] = (byte)bi_buf;
+            }
+            bi_buf = 0;
+            bi_valid = 0;
+        }
+
+        // Copy a stored block, storing first the length and its
+        // one's complement if requested.
+        internal void copy_block(int buf, int len, bool header)
+        {
+            bi_windup(); // align on byte boundary
+            last_eob_len = 8; // enough lookahead for inflate
+
+            if (header)
+                unchecked
+                {
+                    //put_short((short)len);
+                    pending[pendingCount++] = (byte)len;
+                    pending[pendingCount++] = (byte)(len >> 8);
+                    //put_short((short)~len);
+                    pending[pendingCount++] = (byte)~len;
+                    pending[pendingCount++] = (byte)(~len >> 8);
+                }
+
+            put_bytes(window, buf, len);
+        }
+
+        internal void flush_block_only(bool eof)
+        {
+            _tr_flush_block(block_start >= 0 ? block_start : -1, strstart - block_start, eof);
+            block_start = strstart;
+            _codec.flush_pending();
+        }
+
+        // Copy without compression as much as possible from the input stream, return
+        // the current block state.
+        // This function does not insert new strings in the dictionary since
+        // uncompressible data is probably not useful. This function is used
+        // only for the level=0 compression option.
+        // NOTE: this function should be optimized to avoid extra copying from
+        // window to pending_buf.
+        internal BlockState DeflateNone(FlushType flush)
+        {
+            // Stored blocks are limited to 0xffff bytes, pending is limited
+            // to pending_buf_size, and each stored block has a 5 byte header:
+
+            int max_block_size = 0xffff;
+            int max_start;
+
+            if (max_block_size > pending.Length - 5)
+            {
+                max_block_size = pending.Length - 5;
+            }
+
+            // Copy as much as possible from input to output:
+            while (true)
+            {
+                // Fill the window as much as possible:
+                if (lookahead <= 1)
+                {
+                    _fillWindow();
+                    if (lookahead == 0 && flush == FlushType.None)
+                        return BlockState.NeedMore;
+                    if (lookahead == 0)
+                        break; // flush the current block
+                }
+
+                strstart += lookahead;
+                lookahead = 0;
+
+                // Emit a stored block if pending will be full:
+                max_start = block_start + max_block_size;
+                if (strstart == 0 || strstart >= max_start)
+                {
+                    // strstart == 0 is possible when wraparound on 16-bit machine
+                    lookahead = (int)(strstart - max_start);
+                    strstart = (int)max_start;
+
+                    flush_block_only(false);
+                    if (_codec.AvailableBytesOut == 0)
+                        return BlockState.NeedMore;
+                }
+
+                // Flush if we may have to slide, otherwise block_start may become
+                // negative and the data will be gone:
+                if (strstart - block_start >= w_size - MIN_LOOKAHEAD)
+                {
+                    flush_block_only(false);
+                    if (_codec.AvailableBytesOut == 0)
+                        return BlockState.NeedMore;
+                }
+            }
+
+            flush_block_only(flush == FlushType.Finish);
+            if (_codec.AvailableBytesOut == 0)
+                return (flush == FlushType.Finish) ? BlockState.FinishStarted : BlockState.NeedMore;
+
+            return flush == FlushType.Finish ? BlockState.FinishDone : BlockState.BlockDone;
+        }
+
+
+        // Send a stored block
+        internal void _tr_stored_block(int buf, int stored_len, bool eof)
+        {
+            send_bits((STORED_BLOCK << 1) + (eof ? 1 : 0), 3); // send block type
+            copy_block(buf, stored_len, true); // with header
+        }
+
+        // Determine the best encoding for the current block: dynamic trees, static
+        // trees or store, and output the encoded block to the zip file.
+        internal void _tr_flush_block(int buf, int stored_len, bool eof)
+        {
+            int opt_lenb, static_lenb; // opt_len and static_len in bytes
+            int max_blindex = 0; // index of last bit length code of non zero freq
+
+            // Build the Huffman trees unless a stored block is forced
+            if (compressionLevel > 0)
+            {
+                // Check if the file is ascii or binary
+                if (data_type == Z_UNKNOWN)
+                    set_data_type();
+
+                // Construct the literal and distance trees
+                treeLiterals.build_tree(this);
+
+                treeDistances.build_tree(this);
+
+                // At this point, opt_len and static_len are the total bit lengths of
+                // the compressed block data, excluding the tree representations.
+
+                // Build the bit length tree for the above two trees, and get the index
+                // in bl_order of the last bit length code to send.
+                max_blindex = build_bl_tree();
+
+                // Determine the best encoding. Compute first the block length in bytes
+                opt_lenb = (opt_len + 3 + 7) >> 3;
+                static_lenb = (static_len + 3 + 7) >> 3;
+
+                if (static_lenb <= opt_lenb)
+                    opt_lenb = static_lenb;
+            }
+            else
+            {
+                opt_lenb = static_lenb = stored_len + 5; // force a stored block
+            }
+
+            if (stored_len + 4 <= opt_lenb && buf != -1)
+            {
+                // 4: two words for the lengths
+                // The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
+                // Otherwise we can't have processed more than WSIZE input bytes since
+                // the last block flush, because compression would have been
+                // successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
+                // transform a block into a stored block.
+                _tr_stored_block(buf, stored_len, eof);
+            }
+            else if (static_lenb == opt_lenb)
+            {
+                send_bits((STATIC_TREES << 1) + (eof ? 1 : 0), 3);
+                send_compressed_block(StaticTree.lengthAndLiteralsTreeCodes, StaticTree.distTreeCodes);
+            }
+            else
+            {
+                send_bits((DYN_TREES << 1) + (eof ? 1 : 0), 3);
+                send_all_trees(treeLiterals.max_code + 1, treeDistances.max_code + 1, max_blindex + 1);
+                send_compressed_block(dyn_ltree, dyn_dtree);
+            }
+
+            // The above check is made mod 2^32, for files larger than 512 MB
+            // and uLong implemented on 32 bits.
+
+            _InitializeBlocks();
+
+            if (eof)
+            {
+                bi_windup();
+            }
+        }
+
+        // Fill the window when the lookahead becomes insufficient.
+        // Updates strstart and lookahead.
+        //
+        // IN assertion: lookahead < MIN_LOOKAHEAD
+        // OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
+        //    At least one byte has been read, or avail_in == 0; reads are
+        //    performed for at least two bytes (required for the zip translate_eol
+        //    option -- not supported here).
+        private void _fillWindow()
+        {
+            int n, m;
+            int p;
+            int more; // Amount of free space at the end of the window.
+
+            do
+            {
+                more = (window_size - lookahead - strstart);
+
+                // Deal with !@#$% 64K limit:
+                if (more == 0 && strstart == 0 && lookahead == 0)
+                {
+                    more = w_size;
+                }
+                else if (more == -1)
+                {
+                    // Very unlikely, but possible on 16 bit machine if strstart == 0
+                    // and lookahead == 1 (input done one byte at time)
+                    more--;
+
+                    // If the window is almost full and there is insufficient lookahead,
+                    // move the upper half to the lower one to make room in the upper half.
+                }
+                else if (strstart >= w_size + w_size - MIN_LOOKAHEAD)
+                {
+                    Array.Copy(window, w_size, window, 0, w_size);
+                    match_start -= w_size;
+                    strstart -= w_size; // we now have strstart >= MAX_DIST
+                    block_start -= w_size;
+
+                    // Slide the hash table (could be avoided with 32 bit values
+                    // at the expense of memory usage). We slide even when level == 0
+                    // to keep the hash table consistent if we switch back to level > 0
+                    // later. (Using level 0 permanently is not an optimal usage of
+                    // zlib, so we don't care about this pathological case.)
+
+                    n = hash_size;
+                    p = n;
+                    do
+                    {
+                        m = (head[--p] & 0xffff);
+                        head[p] = (short)((m >= w_size) ? (m - w_size) : 0);
+                    }
+                    while (--n != 0);
+
+                    n = w_size;
+                    p = n;
+                    do
+                    {
+                        m = (prev[--p] & 0xffff);
+                        prev[p] = (short)((m >= w_size) ? (m - w_size) : 0);
+                        // If n is not on any hash chain, prev[n] is garbage but
+                        // its value will never be used.
+                    }
+                    while (--n != 0);
+                    more += w_size;
+                }
+
+                if (_codec.AvailableBytesIn == 0)
+                    return;
+
+                // If there was no sliding:
+                //    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
+                //    more == window_size - lookahead - strstart
+                // => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
+                // => more >= window_size - 2*WSIZE + 2
+                // In the BIG_MEM or MMAP case (not yet supported),
+                //   window_size == input_size + MIN_LOOKAHEAD  &&
+                //   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
+                // Otherwise, window_size == 2*WSIZE so more >= 2.
+                // If there was sliding, more >= WSIZE. So in all cases, more >= 2.
+
+                n = _codec.read_buf(window, strstart + lookahead, more);
+                lookahead += n;
+
+                // Initialize the hash value now that we have some input:
+                if (lookahead >= MIN_MATCH)
+                {
+                    ins_h = window[strstart] & 0xff;
+                    ins_h = (((ins_h) << hash_shift) ^ (window[strstart + 1] & 0xff)) & hash_mask;
+                }
+                // If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
+                // but this is not important since only literal bytes will be emitted.
+            }
+            while (lookahead < MIN_LOOKAHEAD && _codec.AvailableBytesIn != 0);
+        }
+
+        // Compress as much as possible from the input stream, return the current
+        // block state.
+        // This function does not perform lazy evaluation of matches and inserts
+        // new strings in the dictionary only for unmatched strings or for short
+        // matches. It is used only for the fast compression options.
+        internal BlockState DeflateFast(FlushType flush)
+        {
+            //    short hash_head = 0; // head of the hash chain
+            int hash_head = 0; // head of the hash chain
+            bool bflush; // set if current block must be flushed
+
+            while (true)
+            {
+                // Make sure that we always have enough lookahead, except
+                // at the end of the input file. We need MAX_MATCH bytes
+                // for the next match, plus MIN_MATCH bytes to insert the
+                // string following the next match.
+                if (lookahead < MIN_LOOKAHEAD)
+                {
+                    _fillWindow();
+                    if (lookahead < MIN_LOOKAHEAD && flush == FlushType.None)
+                    {
+                        return BlockState.NeedMore;
+                    }
+                    if (lookahead == 0)
+                        break; // flush the current block
+                }
+
+                // Insert the string window[strstart .. strstart+2] in the
+                // dictionary, and set hash_head to the head of the hash chain:
+                if (lookahead >= MIN_MATCH)
+                {
+                    ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+
+                    //  prev[strstart&w_mask]=hash_head=head[ins_h];
+                    hash_head = (head[ins_h] & 0xffff);
+                    prev[strstart & w_mask] = head[ins_h];
+                    head[ins_h] = unchecked((short)strstart);
+                }
+
+                // Find the longest match, discarding those <= prev_length.
+                // At this point we have always match_length < MIN_MATCH
+
+                if (hash_head != 0L && ((strstart - hash_head) & 0xffff) <= w_size - MIN_LOOKAHEAD)
+                {
+                    // To simplify the code, we prevent matches with the string
+                    // of window index 0 (in particular we have to avoid a match
+                    // of the string with itself at the start of the input file).
+                    if (compressionStrategy != CompressionStrategy.HuffmanOnly)
+                    {
+                        match_length = longest_match(hash_head);
+                    }
+                    // longest_match() sets match_start
+                }
+                if (match_length >= MIN_MATCH)
+                {
+                    //        check_match(strstart, match_start, match_length);
+
+                    bflush = _tr_tally(strstart - match_start, match_length - MIN_MATCH);
+
+                    lookahead -= match_length;
+
+                    // Insert new strings in the hash table only if the match length
+                    // is not too large. This saves time but degrades compression.
+                    if (match_length <= config.MaxLazy && lookahead >= MIN_MATCH)
+                    {
+                        match_length--; // string at strstart already in hash table
+                        do
+                        {
+                            strstart++;
+
+                            ins_h = ((ins_h << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+                            //      prev[strstart&w_mask]=hash_head=head[ins_h];
+                            hash_head = (head[ins_h] & 0xffff);
+                            prev[strstart & w_mask] = head[ins_h];
+                            head[ins_h] = unchecked((short)strstart);
+
+                            // strstart never exceeds WSIZE-MAX_MATCH, so there are
+                            // always MIN_MATCH bytes ahead.
+                        }
+                        while (--match_length != 0);
+                        strstart++;
+                    }
+                    else
+                    {
+                        strstart += match_length;
+                        match_length = 0;
+                        ins_h = window[strstart] & 0xff;
+
+                        ins_h = (((ins_h) << hash_shift) ^ (window[strstart + 1] & 0xff)) & hash_mask;
+                        // If lookahead < MIN_MATCH, ins_h is garbage, but it does not
+                        // matter since it will be recomputed at next deflate call.
+                    }
+                }
+                else
+                {
+                    // No match, output a literal byte
+
+                    bflush = _tr_tally(0, window[strstart] & 0xff);
+                    lookahead--;
+                    strstart++;
+                }
+                if (bflush)
+                {
+                    flush_block_only(false);
+                    if (_codec.AvailableBytesOut == 0)
+                        return BlockState.NeedMore;
+                }
+            }
+
+            flush_block_only(flush == FlushType.Finish);
+            if (_codec.AvailableBytesOut == 0)
+            {
+                if (flush == FlushType.Finish)
+                    return BlockState.FinishStarted;
+                else
+                    return BlockState.NeedMore;
+            }
+            return flush == FlushType.Finish ? BlockState.FinishDone : BlockState.BlockDone;
+        }
+
+        // Same as above, but achieves better compression. We use a lazy
+        // evaluation for matches: a match is finally adopted only if there is
+        // no better match at the next window position.
+        internal BlockState DeflateSlow(FlushType flush)
+        {
+            //    short hash_head = 0;    // head of hash chain
+            int hash_head = 0; // head of hash chain
+            bool bflush; // set if current block must be flushed
+
+            // Process the input block.
+            while (true)
+            {
+                // Make sure that we always have enough lookahead, except
+                // at the end of the input file. We need MAX_MATCH bytes
+                // for the next match, plus MIN_MATCH bytes to insert the
+                // string following the next match.
+
+                if (lookahead < MIN_LOOKAHEAD)
+                {
+                    _fillWindow();
+                    if (lookahead < MIN_LOOKAHEAD && flush == FlushType.None)
+                        return BlockState.NeedMore;
+
+                    if (lookahead == 0)
+                        break; // flush the current block
+                }
+
+                // Insert the string window[strstart .. strstart+2] in the
+                // dictionary, and set hash_head to the head of the hash chain:
+
+                if (lookahead >= MIN_MATCH)
+                {
+                    ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+                    //  prev[strstart&w_mask]=hash_head=head[ins_h];
+                    hash_head = (head[ins_h] & 0xffff);
+                    prev[strstart & w_mask] = head[ins_h];
+                    head[ins_h] = unchecked((short)strstart);
+                }
+
+                // Find the longest match, discarding those <= prev_length.
+                prev_length = match_length;
+                prev_match = match_start;
+                match_length = MIN_MATCH - 1;
+
+                if (hash_head != 0 && prev_length < config.MaxLazy &&
+                    ((strstart - hash_head) & 0xffff) <= w_size - MIN_LOOKAHEAD)
+                {
+                    // To simplify the code, we prevent matches with the string
+                    // of window index 0 (in particular we have to avoid a match
+                    // of the string with itself at the start of the input file).
+
+                    if (compressionStrategy != CompressionStrategy.HuffmanOnly)
+                    {
+                        match_length = longest_match(hash_head);
+                    }
+                    // longest_match() sets match_start
+
+                    if (match_length <= 5 && (compressionStrategy == CompressionStrategy.Filtered ||
+                                              (match_length == MIN_MATCH && strstart - match_start > 4096)))
+                    {
+
+                        // If prev_match is also MIN_MATCH, match_start is garbage
+                        // but we will ignore the current match anyway.
+                        match_length = MIN_MATCH - 1;
+                    }
+                }
+
+                // If there was a match at the previous step and the current
+                // match is not better, output the previous match:
+                if (prev_length >= MIN_MATCH && match_length <= prev_length)
+                {
+                    int max_insert = strstart + lookahead - MIN_MATCH;
+                    // Do not insert strings in hash table beyond this.
+
+                    //          check_match(strstart-1, prev_match, prev_length);
+
+                    bflush = _tr_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH);
+
+                    // Insert in hash table all strings up to the end of the match.
+                    // strstart-1 and strstart are already inserted. If there is not
+                    // enough lookahead, the last two strings are not inserted in
+                    // the hash table.
+                    lookahead -= (prev_length - 1);
+                    prev_length -= 2;
+                    do
+                    {
+                        if (++strstart <= max_insert)
+                        {
+                            ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+                            //prev[strstart&w_mask]=hash_head=head[ins_h];
+                            hash_head = (head[ins_h] & 0xffff);
+                            prev[strstart & w_mask] = head[ins_h];
+                            head[ins_h] = unchecked((short)strstart);
+                        }
+                    }
+                    while (--prev_length != 0);
+                    match_available = 0;
+                    match_length = MIN_MATCH - 1;
+                    strstart++;
+
+                    if (bflush)
+                    {
+                        flush_block_only(false);
+                        if (_codec.AvailableBytesOut == 0)
+                            return BlockState.NeedMore;
+                    }
+                }
+                else if (match_available != 0)
+                {
+
+                    // If there was no match at the previous position, output a
+                    // single literal. If there was a match but the current match
+                    // is longer, truncate the previous match to a single literal.
+
+                    bflush = _tr_tally(0, window[strstart - 1] & 0xff);
+
+                    if (bflush)
+                    {
+                        flush_block_only(false);
+                    }
+                    strstart++;
+                    lookahead--;
+                    if (_codec.AvailableBytesOut == 0)
+                        return BlockState.NeedMore;
+                }
+                else
+                {
+                    // There is no previous match to compare with, wait for
+                    // the next step to decide.
+
+                    match_available = 1;
+                    strstart++;
+                    lookahead--;
+                }
+            }
+
+            if (match_available != 0)
+            {
+                bflush = _tr_tally(0, window[strstart - 1] & 0xff);
+                match_available = 0;
+            }
+            flush_block_only(flush == FlushType.Finish);
+
+            if (_codec.AvailableBytesOut == 0)
+            {
+                if (flush == FlushType.Finish)
+                    return BlockState.FinishStarted;
+                else
+                    return BlockState.NeedMore;
+            }
+
+            return flush == FlushType.Finish ? BlockState.FinishDone : BlockState.BlockDone;
+        }
+
+
+        internal int longest_match(int cur_match)
+        {
+            int chain_length = config.MaxChainLength; // max hash chain length
+            int scan         = strstart;              // current string
+            int match;                                // matched string
+            int len;                                  // length of current match
+            int best_len     = prev_length;           // best match length so far
+            int limit        = strstart > (w_size - MIN_LOOKAHEAD) ? strstart - (w_size - MIN_LOOKAHEAD) : 0;
+
+            int niceLength = config.NiceLength;
+
+            // Stop when cur_match becomes <= limit. To simplify the code,
+            // we prevent matches with the string of window index 0.
+
+            int wmask = w_mask;
+
+            int strend = strstart + MAX_MATCH;
+            byte scan_end1 = window[scan + best_len - 1];
+            byte scan_end = window[scan + best_len];
+
+            // The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+            // It is easy to get rid of this optimization if necessary.
+
+            // Do not waste too much time if we already have a good match:
+            if (prev_length >= config.GoodLength)
+            {
+                chain_length >>= 2;
+            }
+
+            // Do not look for matches beyond the end of the input. This is necessary
+            // to make deflate deterministic.
+            if (niceLength > lookahead)
+                niceLength = lookahead;
+
+            do
+            {
+                match = cur_match;
+
+                // Skip to next match if the match length cannot increase
+                // or if the match length is less than 2:
+                if (window[match + best_len] != scan_end ||
+                    window[match + best_len - 1] != scan_end1 ||
+                    window[match] != window[scan] ||
+                    window[++match] != window[scan + 1])
+                    continue;
+
+                // The check at best_len-1 can be removed because it will be made
+                // again later. (This heuristic is not always a win.)
+                // It is not necessary to compare scan[2] and match[2] since they
+                // are always equal when the other bytes match, given that
+                // the hash keys are equal and that HASH_BITS >= 8.
+                scan += 2; match++;
+
+                // We check for insufficient lookahead only every 8th comparison;
+                // the 256th check will be made at strstart+258.
+                do
+                {
+                }
+                while (window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] && scan < strend);
+
+                len = MAX_MATCH - (int)(strend - scan);
+                scan = strend - MAX_MATCH;
+
+                if (len > best_len)
+                {
+                    match_start = cur_match;
+                    best_len = len;
+                    if (len >= niceLength)
+                        break;
+                    scan_end1 = window[scan + best_len - 1];
+                    scan_end = window[scan + best_len];
+                }
+            }
+            while ((cur_match = (prev[cur_match & wmask] & 0xffff)) > limit && --chain_length != 0);
+
+            if (best_len <= lookahead)
+                return best_len;
+            return lookahead;
+        }
+
+
+        private bool Rfc1950BytesEmitted = false;
+        private bool _WantRfc1950HeaderBytes = true;
+        internal bool WantRfc1950HeaderBytes
+        {
+            get { return _WantRfc1950HeaderBytes; }
+            set { _WantRfc1950HeaderBytes = value; }
+        }
+
+
+        internal int Initialize(ZlibCodec codec, CompressionLevel level)
+        {
+            return Initialize(codec, level, ZlibConstants.WindowBitsMax);
+        }
+
+        internal int Initialize(ZlibCodec codec, CompressionLevel level, int bits)
+        {
+            return Initialize(codec, level, bits, MEM_LEVEL_DEFAULT, CompressionStrategy.Default);
+        }
+
+        internal int Initialize(ZlibCodec codec, CompressionLevel level, int bits, CompressionStrategy compressionStrategy)
+        {
+            return Initialize(codec, level, bits, MEM_LEVEL_DEFAULT, compressionStrategy);
+        }
+
+        internal int Initialize(ZlibCodec codec, CompressionLevel level, int windowBits, int memLevel, CompressionStrategy strategy)
+        {
+            _codec = codec;
+            _codec.Message = null;
+
+            // validation
+            if (windowBits < 9 || windowBits > 15)
+                throw new ZlibException("windowBits must be in the range 9..15.");
+
+            if (memLevel < 1 || memLevel > MEM_LEVEL_MAX)
+                throw new ZlibException(String.Format("memLevel must be in the range 1.. {0}", MEM_LEVEL_MAX));
+
+            _codec.dstate = this;
+
+            w_bits = windowBits;
+            w_size = 1 << w_bits;
+            w_mask = w_size - 1;
+
+            hash_bits = memLevel + 7;
+            hash_size = 1 << hash_bits;
+            hash_mask = hash_size - 1;
+            hash_shift = ((hash_bits + MIN_MATCH - 1) / MIN_MATCH);
+
+            window = new byte[w_size * 2];
+            prev = new short[w_size];
+            head = new short[hash_size];
+
+            // for memLevel==8, this will be 16384, 16k
+            lit_bufsize = 1 << (memLevel + 6);
+
+            // Use a single array as the buffer for data pending compression,
+            // the output distance codes, and the output length codes (aka tree).
+            // orig comment: This works just fine since the average
+            // output size for (length,distance) codes is <= 24 bits.
+            pending = new byte[lit_bufsize * 4];
+            _distanceOffset = lit_bufsize;
+            _lengthOffset = (1 + 2) * lit_bufsize;
+
+            // So, for memLevel 8, the length of the pending buffer is 65536. 64k.
+            // The first 16k are pending bytes.
+            // The middle slice, of 32k, is used for distance codes.
+            // The final 16k are length codes.
+
+            this.compressionLevel = level;
+            this.compressionStrategy = strategy;
+
+            Reset();
+            return ZlibConstants.Z_OK;
+        }
+
+
+        internal void Reset()
+        {
+            _codec.TotalBytesIn = _codec.TotalBytesOut = 0;
+            _codec.Message = null;
+            //strm.data_type = Z_UNKNOWN;
+
+            pendingCount = 0;
+            nextPending = 0;
+
+            Rfc1950BytesEmitted = false;
+
+            status = (WantRfc1950HeaderBytes) ? INIT_STATE : BUSY_STATE;
+            _codec._Adler32 = Adler.Adler32(0, null, 0, 0);
+
+            last_flush = (int)FlushType.None;
+
+            _InitializeTreeData();
+            _InitializeLazyMatch();
+        }
+
+
+        internal int End()
+        {
+            if (status != INIT_STATE && status != BUSY_STATE && status != FINISH_STATE)
+            {
+                return ZlibConstants.Z_STREAM_ERROR;
+            }
+            // Deallocate in reverse order of allocations:
+            pending = null;
+            head = null;
+            prev = null;
+            window = null;
+            // free
+            // dstate=null;
+            return status == BUSY_STATE ? ZlibConstants.Z_DATA_ERROR : ZlibConstants.Z_OK;
+        }
+
+
+        private void SetDeflater()
+        {
+            switch (config.Flavor)
+            {
+                case DeflateFlavor.Store:
+                    DeflateFunction = DeflateNone;
+                    break;
+                case DeflateFlavor.Fast:
+                    DeflateFunction = DeflateFast;
+                    break;
+                case DeflateFlavor.Slow:
+                    DeflateFunction = DeflateSlow;
+                    break;
+            }
+        }
+
+
+        internal int SetParams(CompressionLevel level, CompressionStrategy strategy)
+        {
+            int result = ZlibConstants.Z_OK;
+
+            if (compressionLevel != level)
+            {
+                Config newConfig = Config.Lookup(level);
+
+                // change in the deflate flavor (Fast vs slow vs none)?
+                if (newConfig.Flavor != config.Flavor && _codec.TotalBytesIn != 0)
+                {
+                    // Flush the last buffer:
+                    result = _codec.Deflate(FlushType.Partial);
+                }
+
+                compressionLevel = level;
+                config = newConfig;
+                SetDeflater();
+            }
+
+            // no need to flush with change in strategy?  Really?
+            compressionStrategy = strategy;
+
+            return result;
+        }
+
+
+        internal int SetDictionary(byte[] dictionary)
+        {
+            int length = dictionary.Length;
+            int index = 0;
+
+            if (dictionary == null || status != INIT_STATE)
+                throw new ZlibException("Stream error.");
+
+            _codec._Adler32 = Adler.Adler32(_codec._Adler32, dictionary, 0, dictionary.Length);
+
+            if (length < MIN_MATCH)
+                return ZlibConstants.Z_OK;
+            if (length > w_size - MIN_LOOKAHEAD)
+            {
+                length = w_size - MIN_LOOKAHEAD;
+                index = dictionary.Length - length; // use the tail of the dictionary
+            }
+            Array.Copy(dictionary, index, window, 0, length);
+            strstart = length;
+            block_start = length;
+
+            // Insert all strings in the hash table (except for the last two bytes).
+            // s->lookahead stays null, so s->ins_h will be recomputed at the next
+            // call of fill_window.
+
+            ins_h = window[0] & 0xff;
+            ins_h = (((ins_h) << hash_shift) ^ (window[1] & 0xff)) & hash_mask;
+
+            for (int n = 0; n <= length - MIN_MATCH; n++)
+            {
+                ins_h = (((ins_h) << hash_shift) ^ (window[(n) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+                prev[n & w_mask] = head[ins_h];
+                head[ins_h] = (short)n;
+            }
+            return ZlibConstants.Z_OK;
+        }
+
+
+
+        internal int Deflate(FlushType flush)
+        {
+            int old_flush;
+
+            if (_codec.OutputBuffer == null ||
+                (_codec.InputBuffer == null && _codec.AvailableBytesIn != 0) ||
+                (status == FINISH_STATE && flush != FlushType.Finish))
+            {
+                _codec.Message = _ErrorMessage[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_STREAM_ERROR)];
+                throw new ZlibException(String.Format("Something is fishy. [{0}]", _codec.Message));
+            }
+            if (_codec.AvailableBytesOut == 0)
+            {
+                _codec.Message = _ErrorMessage[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_BUF_ERROR)];
+                throw new ZlibException("OutputBuffer is full (AvailableBytesOut == 0)");
+            }
+
+            old_flush = last_flush;
+            last_flush = (int)flush;
+
+            // Write the zlib (rfc1950) header bytes
+            if (status == INIT_STATE)
+            {
+                int header = (Z_DEFLATED + ((w_bits - 8) << 4)) << 8;
+                int level_flags = (((int)compressionLevel - 1) & 0xff) >> 1;
+
+                if (level_flags > 3)
+                    level_flags = 3;
+                header |= (level_flags << 6);
+                if (strstart != 0)
+                    header |= PRESET_DICT;
+                header += 31 - (header % 31);
+
+                status = BUSY_STATE;
+                //putShortMSB(header);
+                unchecked
+                {
+                    pending[pendingCount++] = (byte)(header >> 8);
+                    pending[pendingCount++] = (byte)header;
+                }
+                // Save the adler32 of the preset dictionary:
+                if (strstart != 0)
+                {
+                    pending[pendingCount++] = (byte)((_codec._Adler32 & 0xFF000000) >> 24);
+                    pending[pendingCount++] = (byte)((_codec._Adler32 & 0x00FF0000) >> 16);
+                    pending[pendingCount++] = (byte)((_codec._Adler32 & 0x0000FF00) >> 8);
+                    pending[pendingCount++] = (byte)(_codec._Adler32 & 0x000000FF);
+                }
+                _codec._Adler32 = Adler.Adler32(0, null, 0, 0);
+            }
+
+            // Flush as much pending output as possible
+            if (pendingCount != 0)
+            {
+                _codec.flush_pending();
+                if (_codec.AvailableBytesOut == 0)
+                {
+                    //System.out.println("  avail_out==0");
+                    // Since avail_out is 0, deflate will be called again with
+                    // more output space, but possibly with both pending and
+                    // avail_in equal to zero. There won't be anything to do,
+                    // but this is not an error situation so make sure we
+                    // return OK instead of BUF_ERROR at next call of deflate:
+                    last_flush = -1;
+                    return ZlibConstants.Z_OK;
+                }
+
+                // Make sure there is something to do and avoid duplicate consecutive
+                // flushes. For repeated and useless calls with Z_FINISH, we keep
+                // returning Z_STREAM_END instead of Z_BUFF_ERROR.
+            }
+            else if (_codec.AvailableBytesIn == 0 &&
+                     (int)flush <= old_flush &&
+                     flush != FlushType.Finish)
+            {
+                // workitem 8557
+                //
+                // Not sure why this needs to be an error.  pendingCount == 0, which
+                // means there's nothing to deflate.  And the caller has not asked
+                // for a FlushType.Finish, but...  that seems very non-fatal.  We
+                // can just say "OK" and do nothing.
+
+                // _codec.Message = z_errmsg[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_BUF_ERROR)];
+                // throw new ZlibException("AvailableBytesIn == 0 && flush<=old_flush && flush != FlushType.Finish");
+
+                return ZlibConstants.Z_OK;
+            }
+
+            // User must not provide more input after the first FINISH:
+            if (status == FINISH_STATE && _codec.AvailableBytesIn != 0)
+            {
+                _codec.Message = _ErrorMessage[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_BUF_ERROR)];
+                throw new ZlibException("status == FINISH_STATE && _codec.AvailableBytesIn != 0");
+            }
+
+            // Start a new block or continue the current one.
+            if (_codec.AvailableBytesIn != 0 || lookahead != 0 || (flush != FlushType.None && status != FINISH_STATE))
+            {
+                BlockState bstate = DeflateFunction(flush);
+
+                if (bstate == BlockState.FinishStarted || bstate == BlockState.FinishDone)
+                {
+                    status = FINISH_STATE;
+                }
+                if (bstate == BlockState.NeedMore || bstate == BlockState.FinishStarted)
+                {
+                    if (_codec.AvailableBytesOut == 0)
+                    {
+                        last_flush = -1; // avoid BUF_ERROR next call, see above
+                    }
+                    return ZlibConstants.Z_OK;
+                    // If flush != Z_NO_FLUSH && avail_out == 0, the next call
+                    // of deflate should use the same flush parameter to make sure
+                    // that the flush is complete. So we don't have to output an
+                    // empty block here, this will be done at next call. This also
+                    // ensures that for a very small output buffer, we emit at most
+                    // one empty block.
+                }
+
+                if (bstate == BlockState.BlockDone)
+                {
+                    if (flush == FlushType.Partial)
+                    {
+                        _tr_align();
+                    }
+                    else
+                    {
+                        // FlushType.Full or FlushType.Sync
+                        _tr_stored_block(0, 0, false);
+                        // For a full flush, this empty block will be recognized
+                        // as a special marker by inflate_sync().
+                        if (flush == FlushType.Full)
+                        {
+                            // clear hash (forget the history)
+                            for (int i = 0; i < hash_size; i++)
+                                head[i] = 0;
+                        }
+                    }
+                    _codec.flush_pending();
+                    if (_codec.AvailableBytesOut == 0)
+                    {
+                        last_flush = -1; // avoid BUF_ERROR at next call, see above
+                        return ZlibConstants.Z_OK;
+                    }
+                }
+            }
+
+            if (flush != FlushType.Finish)
+                return ZlibConstants.Z_OK;
+
+            if (!WantRfc1950HeaderBytes || Rfc1950BytesEmitted)
+                return ZlibConstants.Z_STREAM_END;
+
+            // Write the zlib trailer (adler32)
+            pending[pendingCount++] = (byte)((_codec._Adler32 & 0xFF000000) >> 24);
+            pending[pendingCount++] = (byte)((_codec._Adler32 & 0x00FF0000) >> 16);
+            pending[pendingCount++] = (byte)((_codec._Adler32 & 0x0000FF00) >> 8);
+            pending[pendingCount++] = (byte)(_codec._Adler32 & 0x000000FF);
+            //putShortMSB((int)(SharedUtils.URShift(_codec._Adler32, 16)));
+            //putShortMSB((int)(_codec._Adler32 & 0xffff));
+
+            _codec.flush_pending();
+
+            // If avail_out is zero, the application will call deflate again
+            // to flush the rest.
+
+            Rfc1950BytesEmitted = true; // write the trailer only once!
+
+            return pendingCount != 0 ? ZlibConstants.Z_OK : ZlibConstants.Z_STREAM_END;
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Deflate/DeflateStream.cs b/MonoGame.Framework/Utilities/Deflate/DeflateStream.cs
new file mode 100644
index 00000000000..ac0bec89488
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Deflate/DeflateStream.cs
@@ -0,0 +1,740 @@
+// DeflateStream.cs
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2009-2010 Dino Chiesa.
+// All rights reserved.
+//
+// This code module is part of DotNetZip, a zipfile class library.
+//
+// ------------------------------------------------------------------
+//
+// This code is licensed under the Microsoft Public License.
+// See the file License.txt for the license details.
+// More info on: http://dotnetzip.codeplex.com
+//
+// ------------------------------------------------------------------
+//
+// last saved (in emacs):
+// Time-stamp: <2011-July-31 14:48:11>
+//
+// ------------------------------------------------------------------
+//
+// This module defines the DeflateStream class, which can be used as a replacement for
+// the System.IO.Compression.DeflateStream class in the .NET BCL.
+//
+// ------------------------------------------------------------------
+
+
+using System;
+
+namespace MonoGame.Utilities.Deflate
+{
+    /// <summary>
+    /// A class for compressing and decompressing streams using the Deflate algorithm.
+    /// </summary>
+    ///
+    /// <remarks>
+    ///
+    /// <para>
+    ///   The DeflateStream is a <see
+    ///   href="http://en.wikipedia.org/wiki/Decorator_pattern">Decorator</see> on a <see
+    ///   cref="System.IO.Stream"/>.  It adds DEFLATE compression or decompression to any
+    ///   stream.
+    /// </para>
+    ///
+    /// <para>
+    ///   Using this stream, applications can compress or decompress data via stream
+    ///   <c>Read</c> and <c>Write</c> operations.  Either compresssion or decompression
+    ///   can occur through either reading or writing. The compression format used is
+    ///   DEFLATE, which is documented in <see
+    ///   href="http://www.ietf.org/rfc/rfc1951.txt">IETF RFC 1951</see>, "DEFLATE
+    ///   Compressed Data Format Specification version 1.3.".
+    /// </para>
+    ///
+    /// <para>
+    ///   This class is similar to <see cref="ZlibStream"/>, except that
+    ///   <c>ZlibStream</c> adds the <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC
+    ///   1950 - ZLIB</see> framing bytes to a compressed stream when compressing, or
+    ///   expects the RFC1950 framing bytes when decompressing. The <c>DeflateStream</c>
+    ///   does not.
+    /// </para>
+    ///
+    /// </remarks>
+    ///
+    /// <seealso cref="ZlibStream" />
+    /// <seealso cref="GZipStream" />
+    public class DeflateStream : System.IO.Stream
+    {
+        internal ZlibBaseStream _baseStream;
+        internal System.IO.Stream _innerStream;
+        bool _disposed;
+
+        /// <summary>
+        ///   Create a DeflateStream using the specified CompressionMode.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   When mode is <c>CompressionMode.Compress</c>, the DeflateStream will use
+        ///   the default compression level. The "captive" stream will be closed when
+        ///   the DeflateStream is closed.
+        /// </remarks>
+        ///
+        /// <example>
+        /// This example uses a DeflateStream to compress data from a file, and writes
+        /// the compressed data to another file.
+        /// <code>
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        /// {
+        ///     using (var raw = System.IO.File.Create(fileToCompress + ".deflated"))
+        ///     {
+        ///         using (Stream compressor = new DeflateStream(raw, CompressionMode.Compress))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n;
+        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
+        ///             {
+        ///                 compressor.Write(buffer, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        ///
+        /// <code lang="VB">
+        /// Using input As Stream = File.OpenRead(fileToCompress)
+        ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".deflated")
+        ///         Using compressor As Stream = New DeflateStream(raw, CompressionMode.Compress)
+        ///             Dim buffer As Byte() = New Byte(4096) {}
+        ///             Dim n As Integer = -1
+        ///             Do While (n &lt;&gt; 0)
+        ///                 If (n &gt; 0) Then
+        ///                     compressor.Write(buffer, 0, n)
+        ///                 End If
+        ///                 n = input.Read(buffer, 0, buffer.Length)
+        ///             Loop
+        ///         End Using
+        ///     End Using
+        /// End Using
+        /// </code>
+        /// </example>
+        /// <param name="stream">The stream which will be read or written.</param>
+        /// <param name="mode">Indicates whether the DeflateStream will compress or decompress.</param>
+        public DeflateStream(System.IO.Stream stream, CompressionMode mode)
+            : this(stream, mode, CompressionLevel.Default, false)
+        {
+        }
+
+        /// <summary>
+        /// Create a DeflateStream using the specified CompressionMode and the specified CompressionLevel.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   When mode is <c>CompressionMode.Decompress</c>, the level parameter is
+        ///   ignored.  The "captive" stream will be closed when the DeflateStream is
+        ///   closed.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        ///
+        ///   This example uses a DeflateStream to compress data from a file, and writes
+        ///   the compressed data to another file.
+        ///
+        /// <code>
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        /// {
+        ///     using (var raw = System.IO.File.Create(fileToCompress + ".deflated"))
+        ///     {
+        ///         using (Stream compressor = new DeflateStream(raw,
+        ///                                                      CompressionMode.Compress,
+        ///                                                      CompressionLevel.BestCompression))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n= -1;
+        ///             while (n != 0)
+        ///             {
+        ///                 if (n &gt; 0)
+        ///                     compressor.Write(buffer, 0, n);
+        ///                 n= input.Read(buffer, 0, buffer.Length);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        ///
+        /// <code lang="VB">
+        /// Using input As Stream = File.OpenRead(fileToCompress)
+        ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".deflated")
+        ///         Using compressor As Stream = New DeflateStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
+        ///             Dim buffer As Byte() = New Byte(4096) {}
+        ///             Dim n As Integer = -1
+        ///             Do While (n &lt;&gt; 0)
+        ///                 If (n &gt; 0) Then
+        ///                     compressor.Write(buffer, 0, n)
+        ///                 End If
+        ///                 n = input.Read(buffer, 0, buffer.Length)
+        ///             Loop
+        ///         End Using
+        ///     End Using
+        /// End Using
+        /// </code>
+        /// </example>
+        /// <param name="stream">The stream to be read or written while deflating or inflating.</param>
+        /// <param name="mode">Indicates whether the <c>DeflateStream</c> will compress or decompress.</param>
+        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
+        public DeflateStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level)
+            : this(stream, mode, level, false)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>DeflateStream</c> using the specified
+        ///   <c>CompressionMode</c>, and explicitly specify whether the
+        ///   stream should be left open after Deflation or Inflation.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   This constructor allows the application to request that the captive stream
+        ///   remain open after the deflation or inflation occurs.  By default, after
+        ///   <c>Close()</c> is called on the stream, the captive stream is also
+        ///   closed. In some cases this is not desired, for example if the stream is a
+        ///   memory stream that will be re-read after compression.  Specify true for
+        ///   the <paramref name="leaveOpen"/> parameter to leave the stream open.
+        /// </para>
+        ///
+        /// <para>
+        ///   The <c>DeflateStream</c> will use the default compression level.
+        /// </para>
+        ///
+        /// <para>
+        ///   See the other overloads of this constructor for example code.
+        /// </para>
+        /// </remarks>
+        ///
+        /// <param name="stream">
+        ///   The stream which will be read or written. This is called the
+        ///   "captive" stream in other places in this documentation.
+        /// </param>
+        ///
+        /// <param name="mode">
+        ///   Indicates whether the <c>DeflateStream</c> will compress or decompress.
+        /// </param>
+        ///
+        /// <param name="leaveOpen">true if the application would like the stream to
+        /// remain open after inflation/deflation.</param>
+        public DeflateStream(System.IO.Stream stream, CompressionMode mode, bool leaveOpen)
+            : this(stream, mode, CompressionLevel.Default, leaveOpen)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>DeflateStream</c> using the specified <c>CompressionMode</c>
+        ///   and the specified <c>CompressionLevel</c>, and explicitly specify whether
+        ///   the stream should be left open after Deflation or Inflation.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   When mode is <c>CompressionMode.Decompress</c>, the level parameter is ignored.
+        /// </para>
+        ///
+        /// <para>
+        ///   This constructor allows the application to request that the captive stream
+        ///   remain open after the deflation or inflation occurs.  By default, after
+        ///   <c>Close()</c> is called on the stream, the captive stream is also
+        ///   closed. In some cases this is not desired, for example if the stream is a
+        ///   <see cref="System.IO.MemoryStream"/> that will be re-read after
+        ///   compression.  Specify true for the <paramref name="leaveOpen"/> parameter
+        ///   to leave the stream open.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        ///
+        ///   This example shows how to use a <c>DeflateStream</c> to compress data from
+        ///   a file, and store the compressed data into another file.
+        ///
+        /// <code>
+        /// using (var output = System.IO.File.Create(fileToCompress + ".deflated"))
+        /// {
+        ///     using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        ///     {
+        ///         using (Stream compressor = new DeflateStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, true))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n= -1;
+        ///             while (n != 0)
+        ///             {
+        ///                 if (n &gt; 0)
+        ///                     compressor.Write(buffer, 0, n);
+        ///                 n= input.Read(buffer, 0, buffer.Length);
+        ///             }
+        ///         }
+        ///     }
+        ///     // can write additional data to the output stream here
+        /// }
+        /// </code>
+        ///
+        /// <code lang="VB">
+        /// Using output As FileStream = File.Create(fileToCompress &amp; ".deflated")
+        ///     Using input As Stream = File.OpenRead(fileToCompress)
+        ///         Using compressor As Stream = New DeflateStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, True)
+        ///             Dim buffer As Byte() = New Byte(4096) {}
+        ///             Dim n As Integer = -1
+        ///             Do While (n &lt;&gt; 0)
+        ///                 If (n &gt; 0) Then
+        ///                     compressor.Write(buffer, 0, n)
+        ///                 End If
+        ///                 n = input.Read(buffer, 0, buffer.Length)
+        ///             Loop
+        ///         End Using
+        ///     End Using
+        ///     ' can write additional data to the output stream here.
+        /// End Using
+        /// </code>
+        /// </example>
+        /// <param name="stream">The stream which will be read or written.</param>
+        /// <param name="mode">Indicates whether the DeflateStream will compress or decompress.</param>
+        /// <param name="leaveOpen">true if the application would like the stream to remain open after inflation/deflation.</param>
+        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
+        public DeflateStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
+        {
+            _innerStream = stream;
+            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.DEFLATE, leaveOpen);
+        }
+
+        #region Zlib properties
+
+        /// <summary>
+        /// This property sets the flush behavior on the stream.
+        /// </summary>
+        /// <remarks> See the ZLIB documentation for the meaning of the flush behavior.
+        /// </remarks>
+        virtual public FlushType FlushMode
+        {
+            get { return (this._baseStream._flushMode); }
+            set
+            {
+                if (_disposed) throw new ObjectDisposedException("DeflateStream");
+                this._baseStream._flushMode = value;
+            }
+        }
+
+        /// <summary>
+        ///   The size of the working buffer for the compression codec.
+        /// </summary>
+        ///
+        /// <remarks>
+        /// <para>
+        ///   The working buffer is used for all stream operations.  The default size is
+        ///   1024 bytes.  The minimum size is 128 bytes. You may get better performance
+        ///   with a larger buffer.  Then again, you might not.  You would have to test
+        ///   it.
+        /// </para>
+        ///
+        /// <para>
+        ///   Set this before the first call to <c>Read()</c> or <c>Write()</c> on the
+        ///   stream. If you try to set it afterwards, it will throw.
+        /// </para>
+        /// </remarks>
+        public int BufferSize
+        {
+            get
+            {
+                return this._baseStream._bufferSize;
+            }
+            set
+            {
+                if (_disposed) throw new ObjectDisposedException("DeflateStream");
+                if (this._baseStream._workingBuffer != null)
+                    throw new ZlibException("The working buffer is already set.");
+                if (value < ZlibConstants.WorkingBufferSizeMin)
+                    throw new ZlibException(String.Format("Don't be silly. {0} bytes?? Use a bigger buffer, at least {1}.", value, ZlibConstants.WorkingBufferSizeMin));
+                this._baseStream._bufferSize = value;
+            }
+        }
+
+        /// <summary>
+        ///   The ZLIB strategy to be used during compression.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   By tweaking this parameter, you may be able to optimize the compression for
+        ///   data with particular characteristics.
+        /// </remarks>
+        public CompressionStrategy Strategy
+        {
+            get
+            {
+                return this._baseStream.Strategy;
+            }
+            set
+            {
+            if (_disposed) throw new ObjectDisposedException("DeflateStream");
+                this._baseStream.Strategy = value;
+            }
+        }
+
+        /// <summary> Returns the total number of bytes input so far.</summary>
+        virtual public long TotalIn
+        {
+            get
+            {
+                return this._baseStream._z.TotalBytesIn;
+            }
+        }
+
+        /// <summary> Returns the total number of bytes output so far.</summary>
+        virtual public long TotalOut
+        {
+            get
+            {
+                return this._baseStream._z.TotalBytesOut;
+            }
+        }
+
+        #endregion
+
+        #region System.IO.Stream methods
+        /// <summary>
+        ///   Dispose the stream.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     This may or may not result in a <c>Close()</c> call on the captive
+        ///     stream.  See the constructors that have a <c>leaveOpen</c> parameter
+        ///     for more information.
+        ///   </para>
+        ///   <para>
+        ///     Application code won't call this code directly.  This method may be
+        ///     invoked in two distinct scenarios.  If disposing == true, the method
+        ///     has been called directly or indirectly by a user's code, for example
+        ///     via the public Dispose() method. In this case, both managed and
+        ///     unmanaged resources can be referenced and disposed.  If disposing ==
+        ///     false, the method has been called by the runtime from inside the
+        ///     object finalizer and this method should not reference other objects;
+        ///     in that case only unmanaged resources must be referenced or
+        ///     disposed.
+        ///   </para>
+        /// </remarks>
+        /// <param name="disposing">
+        ///   true if the Dispose method was invoked by user code.
+        /// </param>
+        protected override void Dispose(bool disposing)
+        {
+            try
+            {
+                if (!_disposed)
+                {
+                    if (disposing && (this._baseStream != null))
+                        this._baseStream.Close();
+                    _disposed = true;
+                }
+            }
+            finally
+            {
+                base.Dispose(disposing);
+            }
+        }
+
+
+
+        /// <summary>
+        /// Indicates whether the stream can be read.
+        /// </summary>
+        /// <remarks>
+        /// The return value depends on whether the captive stream supports reading.
+        /// </remarks>
+        public override bool CanRead
+        {
+            get
+            {
+                if (_disposed) throw new ObjectDisposedException("DeflateStream");
+                return _baseStream._stream.CanRead;
+            }
+        }
+
+        /// <summary>
+        /// Indicates whether the stream supports Seek operations.
+        /// </summary>
+        /// <remarks>
+        /// Always returns false.
+        /// </remarks>
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+
+        /// <summary>
+        /// Indicates whether the stream can be written.
+        /// </summary>
+        /// <remarks>
+        /// The return value depends on whether the captive stream supports writing.
+        /// </remarks>
+        public override bool CanWrite
+        {
+            get
+            {
+                if (_disposed) throw new ObjectDisposedException("DeflateStream");
+                return _baseStream._stream.CanWrite;
+            }
+        }
+
+        /// <summary>
+        /// Flush the stream.
+        /// </summary>
+        public override void Flush()
+        {
+            if (_disposed) throw new ObjectDisposedException("DeflateStream");
+            _baseStream.Flush();
+        }
+
+        /// <summary>
+        /// Reading this property always throws a <see cref="NotImplementedException"/>.
+        /// </summary>
+        public override long Length
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        /// <summary>
+        /// The position of the stream pointer.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Setting this property always throws a <see
+        ///   cref="NotImplementedException"/>. Reading will return the total bytes
+        ///   written out, if used in writing, or the total bytes read in, if used in
+        ///   reading.  The count may refer to compressed bytes or uncompressed bytes,
+        ///   depending on how you've used the stream.
+        /// </remarks>
+        public override long Position
+        {
+            get
+            {
+                if (this._baseStream._streamMode == MonoGame.Utilities.Deflate.ZlibBaseStream.StreamMode.Writer)
+                    return this._baseStream._z.TotalBytesOut;
+                if (this._baseStream._streamMode == MonoGame.Utilities.Deflate.ZlibBaseStream.StreamMode.Reader)
+                    return this._baseStream._z.TotalBytesIn;
+                return 0;
+            }
+            set { throw new NotImplementedException(); }
+        }
+
+        /// <summary>
+        /// Read data from the stream.
+        /// </summary>
+        /// <remarks>
+        ///
+        /// <para>
+        ///   If you wish to use the <c>DeflateStream</c> to compress data while
+        ///   reading, you can create a <c>DeflateStream</c> with
+        ///   <c>CompressionMode.Compress</c>, providing an uncompressed data stream.
+        ///   Then call Read() on that <c>DeflateStream</c>, and the data read will be
+        ///   compressed as you read.  If you wish to use the <c>DeflateStream</c> to
+        ///   decompress data while reading, you can create a <c>DeflateStream</c> with
+        ///   <c>CompressionMode.Decompress</c>, providing a readable compressed data
+        ///   stream.  Then call Read() on that <c>DeflateStream</c>, and the data read
+        ///   will be decompressed as you read.
+        /// </para>
+        ///
+        /// <para>
+        ///   A <c>DeflateStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but not both.
+        /// </para>
+        ///
+        /// </remarks>
+        /// <param name="buffer">The buffer into which the read data should be placed.</param>
+        /// <param name="offset">the offset within that data array to put the first byte read.</param>
+        /// <param name="count">the number of bytes to read.</param>
+        /// <returns>the number of bytes actually read</returns>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (_disposed) throw new ObjectDisposedException("DeflateStream");
+            return _baseStream.Read(buffer, offset, count);
+        }
+
+
+        /// <summary>
+        /// Calling this method always throws a <see cref="NotImplementedException"/>.
+        /// </summary>
+        /// <param name="offset">this is irrelevant, since it will always throw!</param>
+        /// <param name="origin">this is irrelevant, since it will always throw!</param>
+        /// <returns>irrelevant!</returns>
+        public override long Seek(long offset, System.IO.SeekOrigin origin)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Calling this method always throws a <see cref="NotImplementedException"/>.
+        /// </summary>
+        /// <param name="value">this is irrelevant, since it will always throw!</param>
+        public override void SetLength(long value)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        ///   Write data to the stream.
+        /// </summary>
+        /// <remarks>
+        ///
+        /// <para>
+        ///   If you wish to use the <c>DeflateStream</c> to compress data while
+        ///   writing, you can create a <c>DeflateStream</c> with
+        ///   <c>CompressionMode.Compress</c>, and a writable output stream.  Then call
+        ///   <c>Write()</c> on that <c>DeflateStream</c>, providing uncompressed data
+        ///   as input.  The data sent to the output stream will be the compressed form
+        ///   of the data written.  If you wish to use the <c>DeflateStream</c> to
+        ///   decompress data while writing, you can create a <c>DeflateStream</c> with
+        ///   <c>CompressionMode.Decompress</c>, and a writable output stream.  Then
+        ///   call <c>Write()</c> on that stream, providing previously compressed
+        ///   data. The data sent to the output stream will be the decompressed form of
+        ///   the data written.
+        /// </para>
+        ///
+        /// <para>
+        ///   A <c>DeflateStream</c> can be used for <c>Read()</c> or <c>Write()</c>,
+        ///   but not both.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <param name="buffer">The buffer holding data to write to the stream.</param>
+        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
+        /// <param name="count">the number of bytes to write.</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (_disposed) throw new ObjectDisposedException("DeflateStream");
+            _baseStream.Write(buffer, offset, count);
+        }
+        #endregion
+
+
+
+
+        /// <summary>
+        ///   Compress a string into a byte array using DEFLATE (RFC 1951).
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Uncompress it with <see cref="DeflateStream.UncompressString(byte[])"/>.
+        /// </remarks>
+        ///
+        /// <seealso cref="DeflateStream.UncompressString(byte[])">DeflateStream.UncompressString(byte[])</seealso>
+        /// <seealso cref="DeflateStream.CompressBuffer(byte[])">DeflateStream.CompressBuffer(byte[])</seealso>
+        /// <seealso cref="GZipStream.CompressString(string)">GZipStream.CompressString(string)</seealso>
+        /// <seealso cref="ZlibStream.CompressString(string)">ZlibStream.CompressString(string)</seealso>
+        ///
+        /// <param name="s">
+        ///   A string to compress. The string will first be encoded
+        ///   using UTF8, then compressed.
+        /// </param>
+        ///
+        /// <returns>The string in compressed form</returns>
+        public static byte[] CompressString(String s)
+        {
+            using (var ms = new System.IO.MemoryStream())
+            {
+                System.IO.Stream compressor =
+                    new DeflateStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression);
+                ZlibBaseStream.CompressString(s, compressor);
+                return ms.ToArray();
+            }
+        }
+
+
+        /// <summary>
+        ///   Compress a byte array into a new byte array using DEFLATE.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Uncompress it with <see cref="DeflateStream.UncompressBuffer(byte[])"/>.
+        /// </remarks>
+        ///
+        /// <seealso cref="DeflateStream.CompressString(string)">DeflateStream.CompressString(string)</seealso>
+        /// <seealso cref="DeflateStream.UncompressBuffer(byte[])">DeflateStream.UncompressBuffer(byte[])</seealso>
+        /// <seealso cref="GZipStream.CompressBuffer(byte[])">GZipStream.CompressBuffer(byte[])</seealso>
+        /// <seealso cref="ZlibStream.CompressBuffer(byte[])">ZlibStream.CompressBuffer(byte[])</seealso>
+        ///
+        /// <param name="b">
+        ///   A buffer to compress.
+        /// </param>
+        ///
+        /// <returns>The data in compressed form</returns>
+        public static byte[] CompressBuffer(byte[] b)
+        {
+            using (var ms = new System.IO.MemoryStream())
+            {
+                System.IO.Stream compressor =
+                    new DeflateStream( ms, CompressionMode.Compress, CompressionLevel.BestCompression );
+
+                ZlibBaseStream.CompressBuffer(b, compressor);
+                return ms.ToArray();
+            }
+        }
+
+
+        /// <summary>
+        ///   Uncompress a DEFLATE'd byte array into a single string.
+        /// </summary>
+        ///
+        /// <seealso cref="DeflateStream.CompressString(String)">DeflateStream.CompressString(String)</seealso>
+        /// <seealso cref="DeflateStream.UncompressBuffer(byte[])">DeflateStream.UncompressBuffer(byte[])</seealso>
+        /// <seealso cref="GZipStream.UncompressString(byte[])">GZipStream.UncompressString(byte[])</seealso>
+        /// <seealso cref="ZlibStream.UncompressString(byte[])">ZlibStream.UncompressString(byte[])</seealso>
+        ///
+        /// <param name="compressed">
+        ///   A buffer containing DEFLATE-compressed data.
+        /// </param>
+        ///
+        /// <returns>The uncompressed string</returns>
+        public static String UncompressString(byte[] compressed)
+        {
+            using (var input = new System.IO.MemoryStream(compressed))
+            {
+                System.IO.Stream decompressor =
+                    new DeflateStream(input, CompressionMode.Decompress);
+
+                return ZlibBaseStream.UncompressString(compressed, decompressor);
+            }
+        }
+
+
+        /// <summary>
+        ///   Uncompress a DEFLATE'd byte array into a byte array.
+        /// </summary>
+        ///
+        /// <seealso cref="DeflateStream.CompressBuffer(byte[])">DeflateStream.CompressBuffer(byte[])</seealso>
+        /// <seealso cref="DeflateStream.UncompressString(byte[])">DeflateStream.UncompressString(byte[])</seealso>
+        /// <seealso cref="GZipStream.UncompressBuffer(byte[])">GZipStream.UncompressBuffer(byte[])</seealso>
+        /// <seealso cref="ZlibStream.UncompressBuffer(byte[])">ZlibStream.UncompressBuffer(byte[])</seealso>
+        ///
+        /// <param name="compressed">
+        ///   A buffer containing data that has been compressed with DEFLATE.
+        /// </param>
+        ///
+        /// <returns>The data in uncompressed form</returns>
+        public static byte[] UncompressBuffer(byte[] compressed)
+        {
+            using (var input = new System.IO.MemoryStream(compressed))
+            {
+                System.IO.Stream decompressor =
+                    new DeflateStream( input, CompressionMode.Decompress );
+
+                return ZlibBaseStream.UncompressBuffer(compressed, decompressor);
+            }
+        }
+
+    }
+
+}
+
diff --git a/MonoGame.Framework/Utilities/Deflate/GZipStream.cs b/MonoGame.Framework/Utilities/Deflate/GZipStream.cs
new file mode 100644
index 00000000000..cac95c12b83
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Deflate/GZipStream.cs
@@ -0,0 +1,1033 @@
+// GZipStream.cs
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
+// All rights reserved.
+//
+// This code module is part of DotNetZip, a zipfile class library.
+//
+// ------------------------------------------------------------------
+//
+// This code is licensed under the Microsoft Public License.
+// See the file License.txt for the license details.
+// More info on: http://dotnetzip.codeplex.com
+//
+// ------------------------------------------------------------------
+//
+// last saved (in emacs):
+// Time-stamp: <2011-August-08 18:14:39>
+//
+// ------------------------------------------------------------------
+//
+// This module defines the GZipStream class, which can be used as a replacement for
+// the System.IO.Compression.GZipStream class in the .NET BCL.  NB: The design is not
+// completely OO clean: there is some intelligence in the ZlibBaseStream that reads the
+// GZip header.
+//
+// ------------------------------------------------------------------
+
+
+using System;
+using System.IO;
+
+namespace MonoGame.Utilities.Deflate
+{
+    /// <summary>
+    ///   A class for compressing and decompressing GZIP streams.
+    /// </summary>
+    /// <remarks>
+    ///
+    /// <para>
+    ///   The <c>GZipStream</c> is a <see
+    ///   href="http://en.wikipedia.org/wiki/Decorator_pattern">Decorator</see> on a
+    ///   <see cref="Stream"/>. It adds GZIP compression or decompression to any
+    ///   stream.
+    /// </para>
+    ///
+    /// <para>
+    ///   Like the <c>System.IO.Compression.GZipStream</c> in the .NET Base Class Library, the
+    ///   <c>MonoGame.Utilities.Deflate.GZipStream</c> can compress while writing, or decompress while
+    ///   reading, but not vice versa.  The compression method used is GZIP, which is
+    ///   documented in <see href="http://www.ietf.org/rfc/rfc1952.txt">IETF RFC
+    ///   1952</see>, "GZIP file format specification version 4.3".</para>
+    ///
+    /// <para>
+    ///   A <c>GZipStream</c> can be used to decompress data (through <c>Read()</c>) or
+    ///   to compress data (through <c>Write()</c>), but not both.
+    /// </para>
+    ///
+    /// <para>
+    ///   If you wish to use the <c>GZipStream</c> to compress data, you must wrap it
+    ///   around a write-able stream. As you call <c>Write()</c> on the <c>GZipStream</c>, the
+    ///   data will be compressed into the GZIP format.  If you want to decompress data,
+    ///   you must wrap the <c>GZipStream</c> around a readable stream that contains an
+    ///   IETF RFC 1952-compliant stream.  The data will be decompressed as you call
+    ///   <c>Read()</c> on the <c>GZipStream</c>.
+    /// </para>
+    ///
+    /// <para>
+    ///   Though the GZIP format allows data from multiple files to be concatenated
+    ///   together, this stream handles only a single segment of GZIP format, typically
+    ///   representing a single file.
+    /// </para>
+    ///
+    /// <para>
+    ///   This class is similar to <see cref="ZlibStream"/> and <see cref="DeflateStream"/>.
+    ///   <c>ZlibStream</c> handles RFC1950-compliant streams.  <see cref="DeflateStream"/>
+    ///   handles RFC1951-compliant streams. This class handles RFC1952-compliant streams.
+    /// </para>
+    ///
+    /// </remarks>
+    ///
+    /// <seealso cref="DeflateStream" />
+    /// <seealso cref="ZlibStream" />
+    public class GZipStream : System.IO.Stream
+    {
+        // GZip format
+        // source: http://tools.ietf.org/html/rfc1952
+        //
+        //  header id:           2 bytes    1F 8B
+        //  compress method      1 byte     8= DEFLATE (none other supported)
+        //  flag                 1 byte     bitfield (See below)
+        //  mtime                4 bytes    time_t (seconds since jan 1, 1970 UTC of the file.
+        //  xflg                 1 byte     2 = max compress used , 4 = max speed (can be ignored)
+        //  OS                   1 byte     OS for originating archive. set to 0xFF in compression.
+        //  extra field length   2 bytes    optional - only if FEXTRA is set.
+        //  extra field          varies
+        //  filename             varies     optional - if FNAME is set.  zero terminated. ISO-8859-1.
+        //  file comment         varies     optional - if FCOMMENT is set. zero terminated. ISO-8859-1.
+        //  crc16                1 byte     optional - present only if FHCRC bit is set
+        //  compressed data      varies
+        //  CRC32                4 bytes
+        //  isize                4 bytes    data size modulo 2^32
+        //
+        //     FLG (FLaGs)
+        //                bit 0   FTEXT - indicates file is ASCII text (can be safely ignored)
+        //                bit 1   FHCRC - there is a CRC16 for the header immediately following the header
+        //                bit 2   FEXTRA - extra fields are present
+        //                bit 3   FNAME - the zero-terminated filename is present. encoding; ISO-8859-1.
+        //                bit 4   FCOMMENT  - a zero-terminated file comment is present. encoding: ISO-8859-1
+        //                bit 5   reserved
+        //                bit 6   reserved
+        //                bit 7   reserved
+        //
+        // On consumption:
+        // Extra field is a bunch of nonsense and can be safely ignored.
+        // Header CRC and OS, likewise.
+        //
+        // on generation:
+        // all optional fields get 0, except for the OS, which gets 255.
+        //
+
+
+
+        /// <summary>
+        ///   The comment on the GZIP stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        /// <para>
+        ///   The GZIP format allows for each file to optionally have an associated
+        ///   comment stored with the file.  The comment is encoded with the ISO-8859-1
+        ///   code page.  To include a comment in a GZIP stream you create, set this
+        ///   property before calling <c>Write()</c> for the first time on the
+        ///   <c>GZipStream</c>.
+        /// </para>
+        ///
+        /// <para>
+        ///   When using <c>GZipStream</c> to decompress, you can retrieve this property
+        ///   after the first call to <c>Read()</c>.  If no comment has been set in the
+        ///   GZIP bytestream, the Comment property will return <c>null</c>
+        ///   (<c>Nothing</c> in VB).
+        /// </para>
+        /// </remarks>
+        public String Comment
+        {
+            get
+            {
+                return _Comment;
+            }
+            set
+            {
+                if (_disposed) throw new ObjectDisposedException("GZipStream");
+                _Comment = value;
+            }
+        }
+
+        /// <summary>
+        ///   The FileName for the GZIP stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   The GZIP format optionally allows each file to have an associated
+        ///   filename.  When compressing data (through <c>Write()</c>), set this
+        ///   FileName before calling <c>Write()</c> the first time on the <c>GZipStream</c>.
+        ///   The actual filename is encoded into the GZIP bytestream with the
+        ///   ISO-8859-1 code page, according to RFC 1952. It is the application's
+        ///   responsibility to insure that the FileName can be encoded and decoded
+        ///   correctly with this code page.
+        /// </para>
+        ///
+        /// <para>
+        ///   When decompressing (through <c>Read()</c>), you can retrieve this value
+        ///   any time after the first <c>Read()</c>.  In the case where there was no filename
+        ///   encoded into the GZIP bytestream, the property will return <c>null</c> (<c>Nothing</c>
+        ///   in VB).
+        /// </para>
+        /// </remarks>
+        public String FileName
+        {
+            get { return _FileName; }
+            set
+            {
+                if (_disposed) throw new ObjectDisposedException("GZipStream");
+                _FileName = value;
+                if (_FileName == null) return;
+                if (_FileName.IndexOf("/") != -1)
+                {
+                    _FileName = _FileName.Replace("/", "\\");
+                }
+                if (_FileName.EndsWith("\\"))
+                    throw new Exception("Illegal filename");
+                if (_FileName.IndexOf("\\") != -1)
+                {
+                    // trim any leading path
+                    _FileName = Path.GetFileName(_FileName);
+                }
+            }
+        }
+
+        /// <summary>
+        ///   The last modified time for the GZIP stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   GZIP allows the storage of a last modified time with each GZIP entry.
+        ///   When compressing data, you can set this before the first call to
+        ///   <c>Write()</c>.  When decompressing, you can retrieve this value any time
+        ///   after the first call to <c>Read()</c>.
+        /// </remarks>
+        public DateTime? LastModified;
+
+        /// <summary>
+        /// The CRC on the GZIP stream.
+        /// </summary>
+        /// <remarks>
+        /// This is used for internal error checking. You probably don't need to look at this property.
+        /// </remarks>
+        public int Crc32 { get { return _Crc32; } }
+
+        private int _headerByteCount;
+        internal ZlibBaseStream _baseStream;
+        bool _disposed;
+        bool _firstReadDone;
+        string _FileName;
+        string _Comment;
+        int _Crc32;
+
+
+        /// <summary>
+        ///   Create a <c>GZipStream</c> using the specified <c>CompressionMode</c>.
+        /// </summary>
+        /// <remarks>
+        ///
+        /// <para>
+        ///   When mode is <c>CompressionMode.Compress</c>, the <c>GZipStream</c> will use the
+        ///   default compression level.
+        /// </para>
+        ///
+        /// <para>
+        ///   As noted in the class documentation, the <c>CompressionMode</c> (Compress
+        ///   or Decompress) also establishes the "direction" of the stream.  A
+        ///   <c>GZipStream</c> with <c>CompressionMode.Compress</c> works only through
+        ///   <c>Write()</c>.  A <c>GZipStream</c> with
+        ///   <c>CompressionMode.Decompress</c> works only through <c>Read()</c>.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        ///   This example shows how to use a GZipStream to compress data.
+        /// <code>
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        /// {
+        ///     using (var raw = System.IO.File.Create(outputFile))
+        ///     {
+        ///         using (Stream compressor = new GZipStream(raw, CompressionMode.Compress))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n;
+        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
+        ///             {
+        ///                 compressor.Write(buffer, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        /// <code lang="VB">
+        /// Dim outputFile As String = (fileToCompress &amp; ".compressed")
+        /// Using input As Stream = File.OpenRead(fileToCompress)
+        ///     Using raw As FileStream = File.Create(outputFile)
+        ///     Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress)
+        ///         Dim buffer As Byte() = New Byte(4096) {}
+        ///         Dim n As Integer = -1
+        ///         Do While (n &lt;&gt; 0)
+        ///             If (n &gt; 0) Then
+        ///                 compressor.Write(buffer, 0, n)
+        ///             End If
+        ///             n = input.Read(buffer, 0, buffer.Length)
+        ///         Loop
+        ///     End Using
+        ///     End Using
+        /// End Using
+        /// </code>
+        /// </example>
+        ///
+        /// <example>
+        /// This example shows how to use a GZipStream to uncompress a file.
+        /// <code>
+        /// private void GunZipFile(string filename)
+        /// {
+        ///     if (!filename.EndsWith(".gz))
+        ///         throw new ArgumentException("filename");
+        ///     var DecompressedFile = filename.Substring(0,filename.Length-3);
+        ///     byte[] working = new byte[WORKING_BUFFER_SIZE];
+        ///     int n= 1;
+        ///     using (System.IO.Stream input = System.IO.File.OpenRead(filename))
+        ///     {
+        ///         using (Stream decompressor= new MonoGame.Utilities.Deflate.GZipStream(input, CompressionMode.Decompress, true))
+        ///         {
+        ///             using (var output = System.IO.File.Create(DecompressedFile))
+        ///             {
+        ///                 while (n !=0)
+        ///                 {
+        ///                     n= decompressor.Read(working, 0, working.Length);
+        ///                     if (n > 0)
+        ///                     {
+        ///                         output.Write(working, 0, n);
+        ///                     }
+        ///                 }
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        ///
+        /// <code lang="VB">
+        /// Private Sub GunZipFile(ByVal filename as String)
+        ///     If Not (filename.EndsWith(".gz)) Then
+        ///         Throw New ArgumentException("filename")
+        ///     End If
+        ///     Dim DecompressedFile as String = filename.Substring(0,filename.Length-3)
+        ///     Dim working(WORKING_BUFFER_SIZE) as Byte
+        ///     Dim n As Integer = 1
+        ///     Using input As Stream = File.OpenRead(filename)
+        ///         Using decompressor As Stream = new MonoGame.Utilities.Deflate.GZipStream(input, CompressionMode.Decompress, True)
+        ///             Using output As Stream = File.Create(UncompressedFile)
+        ///                 Do
+        ///                     n= decompressor.Read(working, 0, working.Length)
+        ///                     If n > 0 Then
+        ///                         output.Write(working, 0, n)
+        ///                     End IF
+        ///                 Loop While (n  > 0)
+        ///             End Using
+        ///         End Using
+        ///     End Using
+        /// End Sub
+        /// </code>
+        /// </example>
+        ///
+        /// <param name="stream">The stream which will be read or written.</param>
+        /// <param name="mode">Indicates whether the GZipStream will compress or decompress.</param>
+        public GZipStream(Stream stream, CompressionMode mode)
+            : this(stream, mode, CompressionLevel.Default, false)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>GZipStream</c> using the specified <c>CompressionMode</c> and
+        ///   the specified <c>CompressionLevel</c>.
+        /// </summary>
+        /// <remarks>
+        ///
+        /// <para>
+        ///   The <c>CompressionMode</c> (Compress or Decompress) also establishes the
+        ///   "direction" of the stream.  A <c>GZipStream</c> with
+        ///   <c>CompressionMode.Compress</c> works only through <c>Write()</c>.  A
+        ///   <c>GZipStream</c> with <c>CompressionMode.Decompress</c> works only
+        ///   through <c>Read()</c>.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        ///
+        /// This example shows how to use a <c>GZipStream</c> to compress a file into a .gz file.
+        ///
+        /// <code>
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        /// {
+        ///     using (var raw = System.IO.File.Create(fileToCompress + ".gz"))
+        ///     {
+        ///         using (Stream compressor = new GZipStream(raw,
+        ///                                                   CompressionMode.Compress,
+        ///                                                   CompressionLevel.BestCompression))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n;
+        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
+        ///             {
+        ///                 compressor.Write(buffer, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        ///
+        /// <code lang="VB">
+        /// Using input As Stream = File.OpenRead(fileToCompress)
+        ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".gz")
+        ///         Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
+        ///             Dim buffer As Byte() = New Byte(4096) {}
+        ///             Dim n As Integer = -1
+        ///             Do While (n &lt;&gt; 0)
+        ///                 If (n &gt; 0) Then
+        ///                     compressor.Write(buffer, 0, n)
+        ///                 End If
+        ///                 n = input.Read(buffer, 0, buffer.Length)
+        ///             Loop
+        ///         End Using
+        ///     End Using
+        /// End Using
+        /// </code>
+        /// </example>
+        /// <param name="stream">The stream to be read or written while deflating or inflating.</param>
+        /// <param name="mode">Indicates whether the <c>GZipStream</c> will compress or decompress.</param>
+        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
+        public GZipStream(Stream stream, CompressionMode mode, CompressionLevel level)
+            : this(stream, mode, level, false)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>GZipStream</c> using the specified <c>CompressionMode</c>, and
+        ///   explicitly specify whether the stream should be left open after Deflation
+        ///   or Inflation.
+        /// </summary>
+        ///
+        /// <remarks>
+        /// <para>
+        ///   This constructor allows the application to request that the captive stream
+        ///   remain open after the deflation or inflation occurs.  By default, after
+        ///   <c>Close()</c> is called on the stream, the captive stream is also
+        ///   closed. In some cases this is not desired, for example if the stream is a
+        ///   memory stream that will be re-read after compressed data has been written
+        ///   to it.  Specify true for the <paramref name="leaveOpen"/> parameter to leave
+        ///   the stream open.
+        /// </para>
+        ///
+        /// <para>
+        ///   The <see cref="CompressionMode"/> (Compress or Decompress) also
+        ///   establishes the "direction" of the stream.  A <c>GZipStream</c> with
+        ///   <c>CompressionMode.Compress</c> works only through <c>Write()</c>.  A <c>GZipStream</c>
+        ///   with <c>CompressionMode.Decompress</c> works only through <c>Read()</c>.
+        /// </para>
+        ///
+        /// <para>
+        ///   The <c>GZipStream</c> will use the default compression level. If you want
+        ///   to specify the compression level, see <see cref="GZipStream(Stream,
+        ///   CompressionMode, CompressionLevel, bool)"/>.
+        /// </para>
+        ///
+        /// <para>
+        ///   See the other overloads of this constructor for example code.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <param name="stream">
+        ///   The stream which will be read or written. This is called the "captive"
+        ///   stream in other places in this documentation.
+        /// </param>
+        ///
+        /// <param name="mode">Indicates whether the GZipStream will compress or decompress.
+        /// </param>
+        ///
+        /// <param name="leaveOpen">
+        ///   true if the application would like the base stream to remain open after
+        ///   inflation/deflation.
+        /// </param>
+        public GZipStream(Stream stream, CompressionMode mode, bool leaveOpen)
+            : this(stream, mode, CompressionLevel.Default, leaveOpen)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>GZipStream</c> using the specified <c>CompressionMode</c> and the
+        ///   specified <c>CompressionLevel</c>, and explicitly specify whether the
+        ///   stream should be left open after Deflation or Inflation.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   This constructor allows the application to request that the captive stream
+        ///   remain open after the deflation or inflation occurs.  By default, after
+        ///   <c>Close()</c> is called on the stream, the captive stream is also
+        ///   closed. In some cases this is not desired, for example if the stream is a
+        ///   memory stream that will be re-read after compressed data has been written
+        ///   to it.  Specify true for the <paramref name="leaveOpen"/> parameter to
+        ///   leave the stream open.
+        /// </para>
+        ///
+        /// <para>
+        ///   As noted in the class documentation, the <c>CompressionMode</c> (Compress
+        ///   or Decompress) also establishes the "direction" of the stream.  A
+        ///   <c>GZipStream</c> with <c>CompressionMode.Compress</c> works only through
+        ///   <c>Write()</c>.  A <c>GZipStream</c> with <c>CompressionMode.Decompress</c> works only
+        ///   through <c>Read()</c>.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        ///   This example shows how to use a <c>GZipStream</c> to compress data.
+        /// <code>
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        /// {
+        ///     using (var raw = System.IO.File.Create(outputFile))
+        ///     {
+        ///         using (Stream compressor = new GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression, true))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n;
+        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
+        ///             {
+        ///                 compressor.Write(buffer, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        /// <code lang="VB">
+        /// Dim outputFile As String = (fileToCompress &amp; ".compressed")
+        /// Using input As Stream = File.OpenRead(fileToCompress)
+        ///     Using raw As FileStream = File.Create(outputFile)
+        ///     Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression, True)
+        ///         Dim buffer As Byte() = New Byte(4096) {}
+        ///         Dim n As Integer = -1
+        ///         Do While (n &lt;&gt; 0)
+        ///             If (n &gt; 0) Then
+        ///                 compressor.Write(buffer, 0, n)
+        ///             End If
+        ///             n = input.Read(buffer, 0, buffer.Length)
+        ///         Loop
+        ///     End Using
+        ///     End Using
+        /// End Using
+        /// </code>
+        /// </example>
+        /// <param name="stream">The stream which will be read or written.</param>
+        /// <param name="mode">Indicates whether the GZipStream will compress or decompress.</param>
+        /// <param name="leaveOpen">true if the application would like the stream to remain open after inflation/deflation.</param>
+        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
+        public GZipStream(Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
+        {
+            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.GZIP, leaveOpen);
+        }
+
+        #region Zlib properties
+
+        /// <summary>
+        /// This property sets the flush behavior on the stream.
+        /// </summary>
+        virtual public FlushType FlushMode
+        {
+            get { return (this._baseStream._flushMode); }
+            set {
+                if (_disposed) throw new ObjectDisposedException("GZipStream");
+                this._baseStream._flushMode = value;
+            }
+        }
+
+        /// <summary>
+        ///   The size of the working buffer for the compression codec.
+        /// </summary>
+        ///
+        /// <remarks>
+        /// <para>
+        ///   The working buffer is used for all stream operations.  The default size is
+        ///   1024 bytes.  The minimum size is 128 bytes. You may get better performance
+        ///   with a larger buffer.  Then again, you might not.  You would have to test
+        ///   it.
+        /// </para>
+        ///
+        /// <para>
+        ///   Set this before the first call to <c>Read()</c> or <c>Write()</c> on the
+        ///   stream. If you try to set it afterwards, it will throw.
+        /// </para>
+        /// </remarks>
+        public int BufferSize
+        {
+            get
+            {
+                return this._baseStream._bufferSize;
+            }
+            set
+            {
+                if (_disposed) throw new ObjectDisposedException("GZipStream");
+                if (this._baseStream._workingBuffer != null)
+                    throw new ZlibException("The working buffer is already set.");
+                if (value < ZlibConstants.WorkingBufferSizeMin)
+                    throw new ZlibException(String.Format("Don't be silly. {0} bytes?? Use a bigger buffer, at least {1}.", value, ZlibConstants.WorkingBufferSizeMin));
+                this._baseStream._bufferSize = value;
+            }
+        }
+
+
+        /// <summary> Returns the total number of bytes input so far.</summary>
+        virtual public long TotalIn
+        {
+            get
+            {
+                return this._baseStream._z.TotalBytesIn;
+            }
+        }
+
+        /// <summary> Returns the total number of bytes output so far.</summary>
+        virtual public long TotalOut
+        {
+            get
+            {
+                return this._baseStream._z.TotalBytesOut;
+            }
+        }
+
+        #endregion
+
+        #region Stream methods
+
+        /// <summary>
+        ///   Dispose the stream.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     This may or may not result in a <c>Close()</c> call on the captive
+        ///     stream.  See the constructors that have a <c>leaveOpen</c> parameter
+        ///     for more information.
+        ///   </para>
+        ///   <para>
+        ///     This method may be invoked in two distinct scenarios.  If disposing
+        ///     == true, the method has been called directly or indirectly by a
+        ///     user's code, for example via the public Dispose() method. In this
+        ///     case, both managed and unmanaged resources can be referenced and
+        ///     disposed.  If disposing == false, the method has been called by the
+        ///     runtime from inside the object finalizer and this method should not
+        ///     reference other objects; in that case only unmanaged resources must
+        ///     be referenced or disposed.
+        ///   </para>
+        /// </remarks>
+        /// <param name="disposing">
+        ///   indicates whether the Dispose method was invoked by user code.
+        /// </param>
+        protected override void Dispose(bool disposing)
+        {
+            try
+            {
+                if (!_disposed)
+                {
+                    if (disposing && (this._baseStream != null))
+                    {
+                        this._baseStream.Close();
+                        this._Crc32 = _baseStream.Crc32;
+                    }
+                    _disposed = true;
+                }
+            }
+            finally
+            {
+                base.Dispose(disposing);
+            }
+        }
+
+
+        /// <summary>
+        /// Indicates whether the stream can be read.
+        /// </summary>
+        /// <remarks>
+        /// The return value depends on whether the captive stream supports reading.
+        /// </remarks>
+        public override bool CanRead
+        {
+            get
+            {
+                if (_disposed) throw new ObjectDisposedException("GZipStream");
+                return _baseStream._stream.CanRead;
+            }
+        }
+
+        /// <summary>
+        /// Indicates whether the stream supports Seek operations.
+        /// </summary>
+        /// <remarks>
+        /// Always returns false.
+        /// </remarks>
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+
+        /// <summary>
+        /// Indicates whether the stream can be written.
+        /// </summary>
+        /// <remarks>
+        /// The return value depends on whether the captive stream supports writing.
+        /// </remarks>
+        public override bool CanWrite
+        {
+            get
+            {
+                if (_disposed) throw new ObjectDisposedException("GZipStream");
+                return _baseStream._stream.CanWrite;
+            }
+        }
+
+        /// <summary>
+        /// Flush the stream.
+        /// </summary>
+        public override void Flush()
+        {
+            if (_disposed) throw new ObjectDisposedException("GZipStream");
+            _baseStream.Flush();
+        }
+
+        /// <summary>
+        /// Reading this property always throws a <see cref="NotImplementedException"/>.
+        /// </summary>
+        public override long Length
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        /// <summary>
+        ///   The position of the stream pointer.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Setting this property always throws a <see
+        ///   cref="NotImplementedException"/>. Reading will return the total bytes
+        ///   written out, if used in writing, or the total bytes read in, if used in
+        ///   reading.  The count may refer to compressed bytes or uncompressed bytes,
+        ///   depending on how you've used the stream.
+        /// </remarks>
+        public override long Position
+        {
+            get
+            {
+                if (this._baseStream._streamMode == MonoGame.Utilities.Deflate.ZlibBaseStream.StreamMode.Writer)
+                    return this._baseStream._z.TotalBytesOut + _headerByteCount;
+                if (this._baseStream._streamMode == MonoGame.Utilities.Deflate.ZlibBaseStream.StreamMode.Reader)
+                    return this._baseStream._z.TotalBytesIn + this._baseStream._gzipHeaderByteCount;
+                return 0;
+            }
+
+            set { throw new NotImplementedException(); }
+        }
+
+        /// <summary>
+        ///   Read and decompress data from the source stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   With a <c>GZipStream</c>, decompression is done through reading.
+        /// </remarks>
+        ///
+        /// <example>
+        /// <code>
+        /// byte[] working = new byte[WORKING_BUFFER_SIZE];
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(_CompressedFile))
+        /// {
+        ///     using (Stream decompressor= new MonoGame.Utilities.Deflate.GZipStream(input, CompressionMode.Decompress, true))
+        ///     {
+        ///         using (var output = System.IO.File.Create(_DecompressedFile))
+        ///         {
+        ///             int n;
+        ///             while ((n= decompressor.Read(working, 0, working.Length)) !=0)
+        ///             {
+        ///                 output.Write(working, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
+        /// <param name="buffer">The buffer into which the decompressed data should be placed.</param>
+        /// <param name="offset">the offset within that data array to put the first byte read.</param>
+        /// <param name="count">the number of bytes to read.</param>
+        /// <returns>the number of bytes actually read</returns>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (_disposed) throw new ObjectDisposedException("GZipStream");
+            int n = _baseStream.Read(buffer, offset, count);
+
+            // Console.WriteLine("GZipStream::Read(buffer, off({0}), c({1}) = {2}", offset, count, n);
+            // Console.WriteLine( Util.FormatByteArray(buffer, offset, n) );
+
+            if (!_firstReadDone)
+            {
+                _firstReadDone = true;
+                FileName = _baseStream._GzipFileName;
+                Comment = _baseStream._GzipComment;
+            }
+            return n;
+        }
+
+
+
+        /// <summary>
+        ///   Calling this method always throws a <see cref="NotImplementedException"/>.
+        /// </summary>
+        /// <param name="offset">irrelevant; it will always throw!</param>
+        /// <param name="origin">irrelevant; it will always throw!</param>
+        /// <returns>irrelevant!</returns>
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        ///   Calling this method always throws a <see cref="NotImplementedException"/>.
+        /// </summary>
+        /// <param name="value">irrelevant; this method will always throw!</param>
+        public override void SetLength(long value)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        ///   Write data to the stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        /// <para>
+        ///   If you wish to use the <c>GZipStream</c> to compress data while writing,
+        ///   you can create a <c>GZipStream</c> with <c>CompressionMode.Compress</c>, and a
+        ///   writable output stream.  Then call <c>Write()</c> on that <c>GZipStream</c>,
+        ///   providing uncompressed data as input.  The data sent to the output stream
+        ///   will be the compressed form of the data written.
+        /// </para>
+        ///
+        /// <para>
+        ///   A <c>GZipStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but not
+        ///   both. Writing implies compression.  Reading implies decompression.
+        /// </para>
+        ///
+        /// </remarks>
+        /// <param name="buffer">The buffer holding data to write to the stream.</param>
+        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
+        /// <param name="count">the number of bytes to write.</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (_disposed) throw new ObjectDisposedException("GZipStream");
+            if (_baseStream._streamMode == MonoGame.Utilities.Deflate.ZlibBaseStream.StreamMode.Undefined)
+            {
+                //Console.WriteLine("GZipStream: First write");
+                if (_baseStream._wantCompress)
+                {
+                    // first write in compression, therefore, emit the GZIP header
+                    _headerByteCount = EmitHeader();
+                }
+                else
+                {
+                    throw new InvalidOperationException();
+                }
+            }
+
+            _baseStream.Write(buffer, offset, count);
+        }
+        #endregion
+
+
+        internal static readonly System.DateTime _unixEpoch = new System.DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+#if SILVERLIGHT || NETCF
+        internal static readonly System.Text.Encoding iso8859dash1 = new Ionic.Encoding.Iso8859Dash1Encoding();
+#else
+        internal static readonly System.Text.Encoding iso8859dash1 = System.Text.Encoding.GetEncoding("iso-8859-1");
+#endif
+
+
+        private int EmitHeader()
+        {
+            byte[] commentBytes = (Comment == null) ? null : iso8859dash1.GetBytes(Comment);
+            byte[] filenameBytes = (FileName == null) ? null : iso8859dash1.GetBytes(FileName);
+
+            int cbLength = (Comment == null) ? 0 : commentBytes.Length + 1;
+            int fnLength = (FileName == null) ? 0 : filenameBytes.Length + 1;
+
+            int bufferLength = 10 + cbLength + fnLength;
+            byte[] header = new byte[bufferLength];
+            int i = 0;
+            // ID
+            header[i++] = 0x1F;
+            header[i++] = 0x8B;
+
+            // compression method
+            header[i++] = 8;
+            byte flag = 0;
+            if (Comment != null)
+                flag ^= 0x10;
+            if (FileName != null)
+                flag ^= 0x8;
+
+            // flag
+            header[i++] = flag;
+
+            // mtime
+            if (!LastModified.HasValue) LastModified = DateTime.Now;
+            System.TimeSpan delta = LastModified.Value - _unixEpoch;
+            Int32 timet = (Int32)delta.TotalSeconds;
+            Array.Copy(BitConverter.GetBytes(timet), 0, header, i, 4);
+            i += 4;
+
+            // xflg
+            header[i++] = 0;    // this field is totally useless
+            // OS
+            header[i++] = 0xFF; // 0xFF == unspecified
+
+            // extra field length - only if FEXTRA is set, which it is not.
+            //header[i++]= 0;
+            //header[i++]= 0;
+
+            // filename
+            if (fnLength != 0)
+            {
+                Array.Copy(filenameBytes, 0, header, i, fnLength - 1);
+                i += fnLength - 1;
+                header[i++] = 0; // terminate
+            }
+
+            // comment
+            if (cbLength != 0)
+            {
+                Array.Copy(commentBytes, 0, header, i, cbLength - 1);
+                i += cbLength - 1;
+                header[i++] = 0; // terminate
+            }
+
+            _baseStream._stream.Write(header, 0, header.Length);
+
+            return header.Length; // bytes written
+        }
+
+
+
+        /// <summary>
+        ///   Compress a string into a byte array using GZip.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Uncompress it with <see cref="GZipStream.UncompressString(byte[])"/>.
+        /// </remarks>
+        ///
+        /// <seealso cref="GZipStream.UncompressString(byte[])"/>
+        /// <seealso cref="GZipStream.CompressBuffer(byte[])"/>
+        ///
+        /// <param name="s">
+        ///   A string to compress. The string will first be encoded
+        ///   using UTF8, then compressed.
+        /// </param>
+        ///
+        /// <returns>The string in compressed form</returns>
+        public static byte[] CompressString(String s)
+        {
+            using (var ms = new MemoryStream())
+            {
+                System.IO.Stream compressor =
+                    new GZipStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression);
+                ZlibBaseStream.CompressString(s, compressor);
+                return ms.ToArray();
+            }
+        }
+
+
+        /// <summary>
+        ///   Compress a byte array into a new byte array using GZip.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Uncompress it with <see cref="GZipStream.UncompressBuffer(byte[])"/>.
+        /// </remarks>
+        ///
+        /// <seealso cref="GZipStream.CompressString(string)"/>
+        /// <seealso cref="GZipStream.UncompressBuffer(byte[])"/>
+        ///
+        /// <param name="b">
+        ///   A buffer to compress.
+        /// </param>
+        ///
+        /// <returns>The data in compressed form</returns>
+        public static byte[] CompressBuffer(byte[] b)
+        {
+            using (var ms = new MemoryStream())
+            {
+                System.IO.Stream compressor =
+                    new GZipStream( ms, CompressionMode.Compress, CompressionLevel.BestCompression );
+
+                ZlibBaseStream.CompressBuffer(b, compressor);
+                return ms.ToArray();
+            }
+        }
+
+
+        /// <summary>
+        ///   Uncompress a GZip'ed byte array into a single string.
+        /// </summary>
+        ///
+        /// <seealso cref="GZipStream.CompressString(String)"/>
+        /// <seealso cref="GZipStream.UncompressBuffer(byte[])"/>
+        ///
+        /// <param name="compressed">
+        ///   A buffer containing GZIP-compressed data.
+        /// </param>
+        ///
+        /// <returns>The uncompressed string</returns>
+        public static String UncompressString(byte[] compressed)
+        {
+            using (var input = new MemoryStream(compressed))
+            {
+                Stream decompressor = new GZipStream(input, CompressionMode.Decompress);
+                return ZlibBaseStream.UncompressString(compressed, decompressor);
+            }
+        }
+
+
+        /// <summary>
+        ///   Uncompress a GZip'ed byte array into a byte array.
+        /// </summary>
+        ///
+        /// <seealso cref="GZipStream.CompressBuffer(byte[])"/>
+        /// <seealso cref="GZipStream.UncompressString(byte[])"/>
+        ///
+        /// <param name="compressed">
+        ///   A buffer containing data that has been compressed with GZip.
+        /// </param>
+        ///
+        /// <returns>The data in uncompressed form</returns>
+        public static byte[] UncompressBuffer(byte[] compressed)
+        {
+            using (var input = new System.IO.MemoryStream(compressed))
+            {
+                System.IO.Stream decompressor =
+                    new GZipStream( input, CompressionMode.Decompress );
+
+                return ZlibBaseStream.UncompressBuffer(compressed, decompressor);
+            }
+        }
+
+
+    }
+}
diff --git a/MonoGame.Framework/Utilities/Deflate/InfTree.cs b/MonoGame.Framework/Utilities/Deflate/InfTree.cs
new file mode 100644
index 00000000000..a17279d8e5e
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Deflate/InfTree.cs
@@ -0,0 +1,436 @@
+// Inftree.cs
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.  
+// All rights reserved.
+//
+// This code module is part of DotNetZip, a zipfile class library.
+//
+// ------------------------------------------------------------------
+//
+// This code is licensed under the Microsoft Public License. 
+// See the file License.txt for the license details.
+// More info on: http://dotnetzip.codeplex.com
+//
+// ------------------------------------------------------------------
+//
+// last saved (in emacs): 
+// Time-stamp: <2009-October-28 12:43:54>
+//
+// ------------------------------------------------------------------
+//
+// This module defines classes used in  decompression. This code is derived
+// from the jzlib implementation of zlib. In keeping with the license for jzlib, 
+// the copyright to that code is below.
+//
+// ------------------------------------------------------------------
+// 
+// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright 
+// notice, this list of conditions and the following disclaimer in 
+// the documentation and/or other materials provided with the distribution.
+// 
+// 3. The names of the authors may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+// -----------------------------------------------------------------------
+//
+// This program is based on zlib-1.1.3; credit to authors
+// Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+// and contributors of zlib.
+//
+// -----------------------------------------------------------------------
+
+
+
+using System;
+namespace MonoGame.Utilities.Deflate
+{
+        
+        sealed class InfTree
+        {
+                
+                private const int MANY = 1440;
+                
+                private const int Z_OK = 0;
+                private const int Z_STREAM_END = 1;
+                private const int Z_NEED_DICT = 2;
+                private const int Z_ERRNO = - 1;
+                private const int Z_STREAM_ERROR = - 2;
+                private const int Z_DATA_ERROR = - 3;
+                private const int Z_MEM_ERROR = - 4;
+                private const int Z_BUF_ERROR = - 5;
+                private const int Z_VERSION_ERROR = - 6;
+                
+                internal const int fixed_bl = 9;
+                internal const int fixed_bd = 5;
+                
+                //UPGRADE_NOTE: Final was removed from the declaration of 'fixed_tl'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
+                internal static readonly int[] fixed_tl = new int[]{96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9, 192, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 160, 0, 8, 0, 0, 8, 128, 0, 8, 64, 0, 9, 224, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 144, 83, 7, 59, 0, 8, 120, 0, 8, 56, 0, 9, 208, 81, 7, 17, 0, 8, 104, 0, 8, 40, 0, 9, 176, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 240, 80, 7, 4, 0, 8, 84, 0, 8, 20, 85, 8, 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 200, 81, 7, 13, 0, 8, 100, 0, 8, 36, 0, 9, 168, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0, 9, 232, 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 152, 84, 7, 83, 0, 8, 124, 0, 8, 60, 0, 9, 216, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 184, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9, 248, 80, 7, 3, 0, 8, 82, 0, 8, 18, 85, 8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, 9, 196, 81, 7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 164, 0, 8, 2, 0, 8, 130, 0, 8, 66, 0, 9, 228, 80, 7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 148, 84, 7, 67, 0, 8, 122, 0, 8, 58, 0, 9, 212, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, 180, 0, 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 244, 80, 7, 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 204, 81, 7, 15, 0, 8, 102, 0, 8, 38, 0, 9, 172, 0, 8, 6, 0, 8, 134, 0, 8, 70, 0, 9, 236, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, 156, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9, 220, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 188, 0, 8, 14, 0, 8, 142, 0, 8, 78, 0, 9, 252, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0, 8, 113, 0, 8, 49, 0, 9, 194, 80, 7, 10, 0, 8, 97, 0, 8, 33, 0, 9, 162, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 226, 80, 7, 6, 0, 8, 89, 0, 8, 25, 0, 9, 146, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 210, 81, 7, 17, 0, 8, 105, 0, 8, 41, 0, 9, 178, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, 242, 80, 7, 4, 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, 117, 0, 8, 53, 0, 9, 202, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 170, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, 234, 80, 7, 8, 0, 8, 93, 0, 8, 29, 0, 9, 154, 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 218, 82, 7, 23, 0, 8, 109, 0, 8, 45, 0, 9, 186, 
+                        0, 8, 13, 0, 8, 141, 0, 8, 77, 0, 9, 250, 80, 7, 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8, 51, 0, 9, 198, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, 166, 0, 8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 230, 80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 150, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 214, 82, 7, 19, 0, 8, 107, 0, 8, 43, 0, 9, 182, 0, 8, 11, 0, 8, 139, 0, 8, 75, 0, 9, 246, 80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, 0, 9, 206, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 174, 0, 8, 7, 0, 8, 135, 0, 8, 71, 0, 9, 238, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 158, 84, 7, 99, 0, 8, 127, 0, 8, 63, 0, 9, 222, 82, 7, 27, 0, 8, 111, 0, 8, 47, 0, 9, 190, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 254, 96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9, 193, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 161, 0, 8, 0, 0, 8, 128, 0, 8, 64, 0, 9, 225, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 145, 83, 7, 59, 0, 8, 120, 0, 8, 56, 0, 9, 209, 81, 7, 17, 0, 8, 104, 0, 8, 40, 0, 9, 177, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 241, 80, 7, 4, 0, 8, 84, 0, 8, 20, 85, 8, 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 201, 81, 7, 13, 0, 8, 100, 0, 8, 36, 0, 9, 169, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0, 9, 233, 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 153, 84, 7, 83, 0, 8, 124, 0, 8, 60, 0, 9, 217, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 185, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9, 249, 80, 7, 3, 0, 8, 82, 0, 8, 18, 85, 8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, 9, 197, 81, 7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 165, 0, 8, 2, 0, 8, 130, 0, 8, 66, 0, 9, 229, 80, 7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 149, 84, 7, 67, 0, 8, 122, 0, 8, 58, 0, 9, 213, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, 181, 0, 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 245, 80, 7, 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 205, 81, 7, 15, 0, 8, 102, 0, 8, 38, 0, 9, 173, 0, 8, 6, 0, 8, 134, 0, 8, 70, 0, 9, 237, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, 157, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9, 221, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 189, 0, 8, 
+                        14, 0, 8, 142, 0, 8, 78, 0, 9, 253, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0, 8, 113, 0, 8, 49, 0, 9, 195, 80, 7, 10, 0, 8, 97, 0, 8, 33, 0, 9, 163, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 227, 80, 7, 6, 0, 8, 89, 0, 8, 25, 0, 9, 147, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 211, 81, 7, 17, 0, 8, 105, 0, 8, 41, 0, 9, 179, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, 243, 80, 7, 4, 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, 117, 0, 8, 53, 0, 9, 203, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 171, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, 235, 80, 7, 8, 0, 8, 93, 0, 8, 29, 0, 9, 155, 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 219, 82, 7, 23, 0, 8, 109, 0, 8, 45, 0, 9, 187, 0, 8, 13, 0, 8, 141, 0, 8, 77, 0, 9, 251, 80, 7, 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8, 51, 0, 9, 199, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, 167, 0, 8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 231, 80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 151, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 215, 82, 7, 19, 0, 8, 107, 0, 8, 43, 0, 9, 183, 0, 8, 11, 0, 8, 139, 0, 8, 75, 0, 9, 247, 80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, 0, 9, 207, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 175, 0, 8, 7, 0, 8, 135, 0, 8, 71, 0, 9, 239, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 159, 84, 7, 99, 0, 8, 127, 0, 8, 63, 0, 9, 223, 82, 7, 27, 0, 8, 111, 0, 8, 47, 0, 9, 191, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 255};
+                //UPGRADE_NOTE: Final was removed from the declaration of 'fixed_td'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
+                internal static readonly int[] fixed_td = new int[]{80, 5, 1, 87, 5, 257, 83, 5, 17, 91, 5, 4097, 81, 5, 5, 89, 5, 1025, 85, 5, 65, 93, 5, 16385, 80, 5, 3, 88, 5, 513, 84, 5, 33, 92, 5, 8193, 82, 5, 9, 90, 5, 2049, 86, 5, 129, 192, 5, 24577, 80, 5, 2, 87, 5, 385, 83, 5, 25, 91, 5, 6145, 81, 5, 7, 89, 5, 1537, 85, 5, 97, 93, 5, 24577, 80, 5, 4, 88, 5, 769, 84, 5, 49, 92, 5, 12289, 82, 5, 13, 90, 5, 3073, 86, 5, 193, 192, 5, 24577};
+                
+                // Tables for deflate from PKZIP's appnote.txt.
+                //UPGRADE_NOTE: Final was removed from the declaration of 'cplens'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
+                internal static readonly int[] cplens = new int[]{3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
+                
+                // see note #13 above about 258
+                //UPGRADE_NOTE: Final was removed from the declaration of 'cplext'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
+                internal static readonly int[] cplext = new int[]{0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112};
+                
+                //UPGRADE_NOTE: Final was removed from the declaration of 'cpdist'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
+                internal static readonly int[] cpdist = new int[]{1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577};
+                
+                //UPGRADE_NOTE: Final was removed from the declaration of 'cpdext'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
+                internal static readonly int[] cpdext = new int[]{0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13};
+                
+                // If BMAX needs to be larger than 16, then h and x[] should be uLong.
+                internal const int BMAX = 15; // maximum bit length of any code
+                
+                internal int[] hn = null; // hufts used in space
+                internal int[] v = null; // work area for huft_build 
+                internal int[] c = null; // bit length count table
+                internal int[] r = null; // table entry for structure assignment
+                internal int[] u = null; // table stack
+                internal int[] x = null; // bit offsets, then code stack
+                
+                private int huft_build(int[] b, int bindex, int n, int s, int[] d, int[] e, int[] t, int[] m, int[] hp, int[] hn, int[] v)
+                {
+                        // Given a list of code lengths and a maximum table size, make a set of
+                        // tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
+                        // if the given code set is incomplete (the tables are still built in this
+                        // case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
+                        // lengths), or Z_MEM_ERROR if not enough memory.
+                        
+                        int a; // counter for codes of length k
+                        int f; // i repeats in table every f entries
+                        int g; // maximum code length
+                        int h; // table level
+                        int i; // counter, current code
+                        int j; // counter
+                        int k; // number of bits in current code
+                        int l; // bits per table (returned in m)
+                        int mask; // (1 << w) - 1, to avoid cc -O bug on HP
+                        int p; // pointer into c[], b[], or v[]
+                        int q; // points to current table
+                        int w; // bits before this table == (l * h)
+                        int xp; // pointer into x
+                        int y; // number of dummy codes added
+                        int z; // number of entries in current table
+                        
+                        // Generate counts for each bit length
+                        
+                        p = 0; i = n;
+                        do 
+                        {
+                                c[b[bindex + p]]++; p++; i--; // assume all entries <= BMAX
+                        }
+                        while (i != 0);
+                        
+                        if (c[0] == n)
+                        {
+                                // null input--all zero length codes
+                                t[0] = - 1;
+                                m[0] = 0;
+                                return Z_OK;
+                        }
+                        
+                        // Find minimum and maximum length, bound *m by those
+                        l = m[0];
+                        for (j = 1; j <= BMAX; j++)
+                                if (c[j] != 0)
+                                        break;
+                        k = j; // minimum code length
+                        if (l < j)
+                        {
+                                l = j;
+                        }
+                        for (i = BMAX; i != 0; i--)
+                        {
+                                if (c[i] != 0)
+                                        break;
+                        }
+                        g = i; // maximum code length
+                        if (l > i)
+                        {
+                                l = i;
+                        }
+                        m[0] = l;
+                        
+                        // Adjust last length count to fill out codes, if needed
+                        for (y = 1 << j; j < i; j++, y <<= 1)
+                        {
+                                if ((y -= c[j]) < 0)
+                                {
+                                        return Z_DATA_ERROR;
+                                }
+                        }
+                        if ((y -= c[i]) < 0)
+                        {
+                                return Z_DATA_ERROR;
+                        }
+                        c[i] += y;
+                        
+                        // Generate starting offsets into the value table for each length
+                        x[1] = j = 0;
+                        p = 1; xp = 2;
+                        while (--i != 0)
+                        {
+                                // note that i == g from above
+                                x[xp] = (j += c[p]);
+                                xp++;
+                                p++;
+                        }
+                        
+                        // Make a table of values in order of bit lengths
+                        i = 0; p = 0;
+                        do 
+                        {
+                                if ((j = b[bindex + p]) != 0)
+                                {
+                                        v[x[j]++] = i;
+                                }
+                                p++;
+                        }
+                        while (++i < n);
+                        n = x[g]; // set n to length of v
+                        
+                        // Generate the Huffman codes and for each, make the table entries
+                        x[0] = i = 0; // first Huffman code is zero
+                        p = 0; // grab values in bit order
+                        h = - 1; // no tables yet--level -1
+                        w = - l; // bits decoded == (l * h)
+                        u[0] = 0; // just to keep compilers happy
+                        q = 0; // ditto
+                        z = 0; // ditto
+                        
+                        // go through the bit lengths (k already is bits in shortest code)
+                        for (; k <= g; k++)
+                        {
+                                a = c[k];
+                                while (a-- != 0)
+                                {
+                                        // here i is the Huffman code of length k bits for value *p
+                                        // make tables up to required level
+                                        while (k > w + l)
+                                        {
+                                                h++;
+                                                w += l; // previous table always l bits
+                                                // compute minimum size table less than or equal to l bits
+                                                z = g - w;
+                                                z = (z > l)?l:z; // table size upper limit
+                                                if ((f = 1 << (j = k - w)) > a + 1)
+                                                {
+                                                        // try a k-w bit table
+                                                        // too few codes for k-w bit table
+                                                        f -= (a + 1); // deduct codes from patterns left
+                                                        xp = k;
+                                                        if (j < z)
+                                                        {
+                                                                while (++j < z)
+                                                                {
+                                                                        // try smaller tables up to z bits
+                                                                        if ((f <<= 1) <= c[++xp])
+                                                                                break; // enough codes to use up j bits
+                                                                        f -= c[xp]; // else deduct codes from patterns
+                                                                }
+                                                        }
+                                                }
+                                                z = 1 << j; // table entries for j-bit table
+                                                
+                                                // allocate new table
+                                                if (hn[0] + z > MANY)
+                                                {
+                                                        // (note: doesn't matter for fixed)
+                                                        return Z_DATA_ERROR; // overflow of MANY
+                                                }
+                                                u[h] = q = hn[0]; // DEBUG
+                                                hn[0] += z;
+                                                
+                                                // connect to last table, if there is one
+                                                if (h != 0)
+                                                {
+                                                        x[h] = i; // save pattern for backing up
+                                                        r[0] = (sbyte) j; // bits in this table
+                                                        r[1] = (sbyte) l; // bits to dump before this table
+                                                        j = SharedUtils.URShift(i, (w - l));
+                                                        r[2] = (int) (q - u[h - 1] - j); // offset to this table
+                                                        Array.Copy(r, 0, hp, (u[h - 1] + j) * 3, 3); // connect to last table
+                                                }
+                                                else
+                                                {
+                                                        t[0] = q; // first table is returned result
+                                                }
+                                        }
+                                        
+                                        // set up table entry in r
+                                        r[1] = (sbyte) (k - w);
+                                        if (p >= n)
+                                        {
+                                                r[0] = 128 + 64; // out of values--invalid code
+                                        }
+                                        else if (v[p] < s)
+                                        {
+                                                r[0] = (sbyte) (v[p] < 256?0:32 + 64); // 256 is end-of-block
+                                                r[2] = v[p++]; // simple code is just the value
+                                        }
+                                        else
+                                        {
+                                                r[0] = (sbyte) (e[v[p] - s] + 16 + 64); // non-simple--look up in lists
+                                                r[2] = d[v[p++] - s];
+                                        }
+                                        
+                                        // fill code-like entries with r
+                                        f = 1 << (k - w);
+                                        for (j = SharedUtils.URShift(i, w); j < z; j += f)
+                                        {
+                                                Array.Copy(r, 0, hp, (q + j) * 3, 3);
+                                        }
+                                        
+                                        // backwards increment the k-bit code i
+                                        for (j = 1 << (k - 1); (i & j) != 0; j = SharedUtils.URShift(j, 1))
+                                        {
+                                                i ^= j;
+                                        }
+                                        i ^= j;
+                                        
+                                        // backup over finished tables
+                                        mask = (1 << w) - 1; // needed on HP, cc -O bug
+                                        while ((i & mask) != x[h])
+                                        {
+                                                h--; // don't need to update q
+                                                w -= l;
+                                                mask = (1 << w) - 1;
+                                        }
+                                }
+                        }
+                        // Return Z_BUF_ERROR if we were given an incomplete table
+                        return y != 0 && g != 1?Z_BUF_ERROR:Z_OK;
+                }
+                
+                internal int inflate_trees_bits(int[] c, int[] bb, int[] tb, int[] hp, ZlibCodec z)
+                {
+                        int result;
+                        initWorkArea(19);
+                        hn[0] = 0;
+                        result = huft_build(c, 0, 19, 19, null, null, tb, bb, hp, hn, v);
+                        
+                        if (result == Z_DATA_ERROR)
+                        {
+                                z.Message = "oversubscribed dynamic bit lengths tree";
+                        }
+                        else if (result == Z_BUF_ERROR || bb[0] == 0)
+                        {
+                                z.Message = "incomplete dynamic bit lengths tree";
+                                result = Z_DATA_ERROR;
+                        }
+                        return result;
+                }
+                
+                internal int inflate_trees_dynamic(int nl, int nd, int[] c, int[] bl, int[] bd, int[] tl, int[] td, int[] hp, ZlibCodec z)
+                {
+                        int result;
+                        
+                        // build literal/length tree
+                        initWorkArea(288);
+                        hn[0] = 0;
+                        result = huft_build(c, 0, nl, 257, cplens, cplext, tl, bl, hp, hn, v);
+                        if (result != Z_OK || bl[0] == 0)
+                        {
+                                if (result == Z_DATA_ERROR)
+                                {
+                                        z.Message = "oversubscribed literal/length tree";
+                                }
+                                else if (result != Z_MEM_ERROR)
+                                {
+                                        z.Message = "incomplete literal/length tree";
+                                        result = Z_DATA_ERROR;
+                                }
+                                return result;
+                        }
+                        
+                        // build distance tree
+                        initWorkArea(288);
+                        result = huft_build(c, nl, nd, 0, cpdist, cpdext, td, bd, hp, hn, v);
+                        
+                        if (result != Z_OK || (bd[0] == 0 && nl > 257))
+                        {
+                                if (result == Z_DATA_ERROR)
+                                {
+                                        z.Message = "oversubscribed distance tree";
+                                }
+                                else if (result == Z_BUF_ERROR)
+                                {
+                                        z.Message = "incomplete distance tree";
+                                        result = Z_DATA_ERROR;
+                                }
+                                else if (result != Z_MEM_ERROR)
+                                {
+                                        z.Message = "empty distance tree with lengths";
+                                        result = Z_DATA_ERROR;
+                                }
+                                return result;
+                        }
+                        
+                        return Z_OK;
+                }
+                
+                internal static int inflate_trees_fixed(int[] bl, int[] bd, int[][] tl, int[][] td, ZlibCodec z)
+                {
+                        bl[0] = fixed_bl;
+                        bd[0] = fixed_bd;
+                        tl[0] = fixed_tl;
+                        td[0] = fixed_td;
+                        return Z_OK;
+                }
+                
+                private void  initWorkArea(int vsize)
+                {
+                        if (hn == null)
+                        {
+                                hn = new int[1];
+                                v = new int[vsize];
+                                c = new int[BMAX + 1];
+                                r = new int[3];
+                                u = new int[BMAX];
+                                x = new int[BMAX + 1];
+                        }
+                        else
+                        {
+                            if (v.Length < vsize)
+                            {
+                                v = new int[vsize];
+                            }
+                            Array.Clear(v,0,vsize);
+                            Array.Clear(c,0,BMAX+1);
+                            r[0]=0; r[1]=0; r[2]=0;
+                            //  for(int i=0; i<BMAX; i++){u[i]=0;}
+                            //Array.Copy(c, 0, u, 0, BMAX);
+                            Array.Clear(u,0,BMAX);
+                            //  for(int i=0; i<BMAX+1; i++){x[i]=0;}
+                            //Array.Copy(c, 0, x, 0, BMAX + 1);
+                            Array.Clear(x,0,BMAX+1);
+                        }
+                }
+        }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Deflate/Inflate.cs b/MonoGame.Framework/Utilities/Deflate/Inflate.cs
new file mode 100644
index 00000000000..3620f101423
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Deflate/Inflate.cs
@@ -0,0 +1,1796 @@
+// Inflate.cs
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
+// All rights reserved.
+//
+// This code module is part of DotNetZip, a zipfile class library.
+//
+// ------------------------------------------------------------------
+//
+// This code is licensed under the Microsoft Public License.
+// See the file License.txt for the license details.
+// More info on: http://dotnetzip.codeplex.com
+//
+// ------------------------------------------------------------------
+//
+// last saved (in emacs):
+// Time-stamp: <2010-January-08 18:32:12>
+//
+// ------------------------------------------------------------------
+//
+// This module defines classes for decompression. This code is derived
+// from the jzlib implementation of zlib, but significantly modified.
+// The object model is not the same, and many of the behaviors are
+// different.  Nonetheless, in keeping with the license for jzlib, I am
+// reproducing the copyright to that code here.
+//
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in
+// the documentation and/or other materials provided with the distribution.
+//
+// 3. The names of the authors may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// -----------------------------------------------------------------------
+//
+// This program is based on zlib-1.1.3; credit to authors
+// Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+// and contributors of zlib.
+//
+// -----------------------------------------------------------------------
+
+
+using System;
+namespace MonoGame.Utilities.Deflate
+{
+    sealed class InflateBlocks
+    {
+        private const int MANY = 1440;
+
+        // Table for deflate from PKZIP's appnote.txt.
+        internal static readonly int[] border = new int[]
+        { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
+
+        private enum InflateBlockMode
+        {
+            TYPE   = 0,                     // get type bits (3, including end bit)
+            LENS   = 1,                     // get lengths for stored
+            STORED = 2,                     // processing stored block
+            TABLE  = 3,                     // get table lengths
+            BTREE  = 4,                     // get bit lengths tree for a dynamic block
+            DTREE  = 5,                     // get length, distance trees for a dynamic block
+            CODES  = 6,                     // processing fixed or dynamic block
+            DRY    = 7,                     // output remaining window bytes
+            DONE   = 8,                     // finished last block, done
+            BAD    = 9,                     // ot a data error--stuck here
+        }
+
+        private InflateBlockMode mode;                    // current inflate_block mode
+
+        internal int left;                                // if STORED, bytes left to copy
+
+        internal int table;                               // table lengths (14 bits)
+        internal int index;                               // index into blens (or border)
+        internal int[] blens;                             // bit lengths of codes
+        internal int[] bb = new int[1];                   // bit length tree depth
+        internal int[] tb = new int[1];                   // bit length decoding tree
+
+        internal InflateCodes codes = new InflateCodes(); // if CODES, current state
+
+        internal int last;                                // true if this block is the last block
+
+        internal ZlibCodec _codec;                        // pointer back to this zlib stream
+
+                                                          // mode independent information
+        internal int bitk;                                // bits in bit buffer
+        internal int bitb;                                // bit buffer
+        internal int[] hufts;                             // single malloc for tree space
+        internal byte[] window;                           // sliding window
+        internal int end;                                 // one byte after sliding window
+        internal int readAt;                              // window read pointer
+        internal int writeAt;                             // window write pointer
+        internal System.Object checkfn;                   // check function
+        internal uint check;                              // check on output
+
+        internal InfTree inftree = new InfTree();
+
+        internal InflateBlocks(ZlibCodec codec, System.Object checkfn, int w)
+        {
+            _codec = codec;
+            hufts = new int[MANY * 3];
+            window = new byte[w];
+            end = w;
+            this.checkfn = checkfn;
+            mode = InflateBlockMode.TYPE;
+            Reset();
+        }
+
+        internal uint Reset()
+        {
+            uint oldCheck = check;
+            mode = InflateBlockMode.TYPE;
+            bitk = 0;
+            bitb = 0;
+            readAt = writeAt = 0;
+
+            if (checkfn != null)
+                _codec._Adler32 = check = Adler.Adler32(0, null, 0, 0);
+            return oldCheck;
+        }
+
+
+        internal int Process(int r)
+        {
+            int t; // temporary storage
+            int b; // bit buffer
+            int k; // bits in bit buffer
+            int p; // input data pointer
+            int n; // bytes available there
+            int q; // output window write pointer
+            int m; // bytes to end of window or read pointer
+
+            // copy input/output information to locals (UPDATE macro restores)
+
+            p = _codec.NextIn;
+            n = _codec.AvailableBytesIn;
+            b = bitb;
+            k = bitk;
+
+            q = writeAt;
+            m = (int)(q < readAt ? readAt - q - 1 : end - q);
+
+
+            // process input based on current state
+            while (true)
+            {
+                switch (mode)
+                {
+                    case InflateBlockMode.TYPE:
+
+                        while (k < (3))
+                        {
+                            if (n != 0)
+                            {
+                                r = ZlibConstants.Z_OK;
+                            }
+                            else
+                            {
+                                bitb = b; bitk = k;
+                                _codec.AvailableBytesIn = n;
+                                _codec.TotalBytesIn += p - _codec.NextIn;
+                                _codec.NextIn = p;
+                                writeAt = q;
+                                return Flush(r);
+                            }
+
+                            n--;
+                            b |= (_codec.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+                        t = (int)(b & 7);
+                        last = t & 1;
+
+                        switch ((uint)t >> 1)
+                        {
+                            case 0:  // stored
+                                b >>= 3; k -= (3);
+                                t = k & 7; // go to byte boundary
+                                b >>= t; k -= t;
+                                mode = InflateBlockMode.LENS; // get length of stored block
+                                break;
+
+                            case 1:  // fixed
+                                int[] bl = new int[1];
+                                int[] bd = new int[1];
+                                int[][] tl = new int[1][];
+                                int[][] td = new int[1][];
+                                InfTree.inflate_trees_fixed(bl, bd, tl, td, _codec);
+                                codes.Init(bl[0], bd[0], tl[0], 0, td[0], 0);
+                                b >>= 3; k -= 3;
+                                mode = InflateBlockMode.CODES;
+                                break;
+
+                            case 2:  // dynamic
+                                b >>= 3; k -= 3;
+                                mode = InflateBlockMode.TABLE;
+                                break;
+
+                            case 3:  // illegal
+                                b >>= 3; k -= 3;
+                                mode = InflateBlockMode.BAD;
+                                _codec.Message = "invalid block type";
+                                r = ZlibConstants.Z_DATA_ERROR;
+                                bitb = b; bitk = k;
+                                _codec.AvailableBytesIn = n;
+                                _codec.TotalBytesIn += p - _codec.NextIn;
+                                _codec.NextIn = p;
+                                writeAt = q;
+                                return Flush(r);
+                        }
+                        break;
+
+                    case InflateBlockMode.LENS:
+
+                        while (k < (32))
+                        {
+                            if (n != 0)
+                            {
+                                r = ZlibConstants.Z_OK;
+                            }
+                            else
+                            {
+                                bitb = b; bitk = k;
+                                _codec.AvailableBytesIn = n;
+                                _codec.TotalBytesIn += p - _codec.NextIn;
+                                _codec.NextIn = p;
+                                writeAt = q;
+                                return Flush(r);
+                            }
+                            ;
+                            n--;
+                            b |= (_codec.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+
+                        if ( ( ((~b)>>16) & 0xffff) != (b & 0xffff))
+                        {
+                            mode = InflateBlockMode.BAD;
+                            _codec.Message = "invalid stored block lengths";
+                            r = ZlibConstants.Z_DATA_ERROR;
+
+                            bitb = b; bitk = k;
+                            _codec.AvailableBytesIn = n;
+                            _codec.TotalBytesIn += p - _codec.NextIn;
+                            _codec.NextIn = p;
+                            writeAt = q;
+                            return Flush(r);
+                        }
+                        left = (b & 0xffff);
+                        b = k = 0; // dump bits
+                        mode = left != 0 ? InflateBlockMode.STORED : (last != 0 ? InflateBlockMode.DRY : InflateBlockMode.TYPE);
+                        break;
+
+                    case InflateBlockMode.STORED:
+                        if (n == 0)
+                        {
+                            bitb = b; bitk = k;
+                            _codec.AvailableBytesIn = n;
+                            _codec.TotalBytesIn += p - _codec.NextIn;
+                            _codec.NextIn = p;
+                            writeAt = q;
+                            return Flush(r);
+                        }
+
+                        if (m == 0)
+                        {
+                            if (q == end && readAt != 0)
+                            {
+                                q = 0; m = (int)(q < readAt ? readAt - q - 1 : end - q);
+                            }
+                            if (m == 0)
+                            {
+                                writeAt = q;
+                                r = Flush(r);
+                                q = writeAt; m = (int)(q < readAt ? readAt - q - 1 : end - q);
+                                if (q == end && readAt != 0)
+                                {
+                                    q = 0; m = (int)(q < readAt ? readAt - q - 1 : end - q);
+                                }
+                                if (m == 0)
+                                {
+                                    bitb = b; bitk = k;
+                                    _codec.AvailableBytesIn = n;
+                                    _codec.TotalBytesIn += p - _codec.NextIn;
+                                    _codec.NextIn = p;
+                                    writeAt = q;
+                                    return Flush(r);
+                                }
+                            }
+                        }
+                        r = ZlibConstants.Z_OK;
+
+                        t = left;
+                        if (t > n)
+                            t = n;
+                        if (t > m)
+                            t = m;
+                        Array.Copy(_codec.InputBuffer, p, window, q, t);
+                        p += t; n -= t;
+                        q += t; m -= t;
+                        if ((left -= t) != 0)
+                            break;
+                        mode = last != 0 ? InflateBlockMode.DRY : InflateBlockMode.TYPE;
+                        break;
+
+                    case InflateBlockMode.TABLE:
+
+                        while (k < (14))
+                        {
+                            if (n != 0)
+                            {
+                                r = ZlibConstants.Z_OK;
+                            }
+                            else
+                            {
+                                bitb = b; bitk = k;
+                                _codec.AvailableBytesIn = n;
+                                _codec.TotalBytesIn += p - _codec.NextIn;
+                                _codec.NextIn = p;
+                                writeAt = q;
+                                return Flush(r);
+                            }
+
+                            n--;
+                            b |= (_codec.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+
+                        table = t = (b & 0x3fff);
+                        if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
+                        {
+                            mode = InflateBlockMode.BAD;
+                            _codec.Message = "too many length or distance symbols";
+                            r = ZlibConstants.Z_DATA_ERROR;
+
+                            bitb = b; bitk = k;
+                            _codec.AvailableBytesIn = n;
+                            _codec.TotalBytesIn += p - _codec.NextIn;
+                            _codec.NextIn = p;
+                            writeAt = q;
+                            return Flush(r);
+                        }
+                        t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
+                        if (blens == null || blens.Length < t)
+                        {
+                            blens = new int[t];
+                        }
+                        else
+                        {
+                            Array.Clear(blens, 0, t);
+                            // for (int i = 0; i < t; i++)
+                            // {
+                            //     blens[i] = 0;
+                            // }
+                        }
+
+                        b >>= 14;
+                        k -= 14;
+
+
+                        index = 0;
+                        mode = InflateBlockMode.BTREE;
+                        goto case InflateBlockMode.BTREE;
+
+                    case InflateBlockMode.BTREE:
+                        while (index < 4 + (table >> 10))
+                        {
+                            while (k < (3))
+                            {
+                                if (n != 0)
+                                {
+                                    r = ZlibConstants.Z_OK;
+                                }
+                                else
+                                {
+                                    bitb = b; bitk = k;
+                                    _codec.AvailableBytesIn = n;
+                                    _codec.TotalBytesIn += p - _codec.NextIn;
+                                    _codec.NextIn = p;
+                                    writeAt = q;
+                                    return Flush(r);
+                                }
+
+                                n--;
+                                b |= (_codec.InputBuffer[p++] & 0xff) << k;
+                                k += 8;
+                            }
+
+                            blens[border[index++]] = b & 7;
+
+                            b >>= 3; k -= 3;
+                        }
+
+                        while (index < 19)
+                        {
+                            blens[border[index++]] = 0;
+                        }
+
+                        bb[0] = 7;
+                        t = inftree.inflate_trees_bits(blens, bb, tb, hufts, _codec);
+                        if (t != ZlibConstants.Z_OK)
+                        {
+                            r = t;
+                            if (r == ZlibConstants.Z_DATA_ERROR)
+                            {
+                                blens = null;
+                                mode = InflateBlockMode.BAD;
+                            }
+
+                            bitb = b; bitk = k;
+                            _codec.AvailableBytesIn = n;
+                            _codec.TotalBytesIn += p - _codec.NextIn;
+                            _codec.NextIn = p;
+                            writeAt = q;
+                            return Flush(r);
+                        }
+
+                        index = 0;
+                        mode = InflateBlockMode.DTREE;
+                        goto case InflateBlockMode.DTREE;
+
+                    case InflateBlockMode.DTREE:
+                        while (true)
+                        {
+                            t = table;
+                            if (!(index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f)))
+                            {
+                                break;
+                            }
+
+                            int i, j, c;
+
+                            t = bb[0];
+
+                            while (k < t)
+                            {
+                                if (n != 0)
+                                {
+                                    r = ZlibConstants.Z_OK;
+                                }
+                                else
+                                {
+                                    bitb = b; bitk = k;
+                                    _codec.AvailableBytesIn = n;
+                                    _codec.TotalBytesIn += p - _codec.NextIn;
+                                    _codec.NextIn = p;
+                                    writeAt = q;
+                                    return Flush(r);
+                                }
+
+                                n--;
+                                b |= (_codec.InputBuffer[p++] & 0xff) << k;
+                                k += 8;
+                            }
+
+                            t = hufts[(tb[0] + (b & InternalInflateConstants.InflateMask[t])) * 3 + 1];
+                            c = hufts[(tb[0] + (b & InternalInflateConstants.InflateMask[t])) * 3 + 2];
+
+                            if (c < 16)
+                            {
+                                b >>= t; k -= t;
+                                blens[index++] = c;
+                            }
+                            else
+                            {
+                                // c == 16..18
+                                i = c == 18 ? 7 : c - 14;
+                                j = c == 18 ? 11 : 3;
+
+                                while (k < (t + i))
+                                {
+                                    if (n != 0)
+                                    {
+                                        r = ZlibConstants.Z_OK;
+                                    }
+                                    else
+                                    {
+                                        bitb = b; bitk = k;
+                                        _codec.AvailableBytesIn = n;
+                                        _codec.TotalBytesIn += p - _codec.NextIn;
+                                        _codec.NextIn = p;
+                                        writeAt = q;
+                                        return Flush(r);
+                                    }
+
+                                    n--;
+                                    b |= (_codec.InputBuffer[p++] & 0xff) << k;
+                                    k += 8;
+                                }
+
+                                b >>= t; k -= t;
+
+                                j += (b & InternalInflateConstants.InflateMask[i]);
+
+                                b >>= i; k -= i;
+
+                                i = index;
+                                t = table;
+                                if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || (c == 16 && i < 1))
+                                {
+                                    blens = null;
+                                    mode = InflateBlockMode.BAD;
+                                    _codec.Message = "invalid bit length repeat";
+                                    r = ZlibConstants.Z_DATA_ERROR;
+
+                                    bitb = b; bitk = k;
+                                    _codec.AvailableBytesIn = n;
+                                    _codec.TotalBytesIn += p - _codec.NextIn;
+                                    _codec.NextIn = p;
+                                    writeAt = q;
+                                    return Flush(r);
+                                }
+
+                                c = (c == 16) ? blens[i-1] : 0;
+                                do
+                                {
+                                    blens[i++] = c;
+                                }
+                                while (--j != 0);
+                                index = i;
+                            }
+                        }
+
+                        tb[0] = -1;
+                        {
+                            int[] bl = new int[] { 9 };  // must be <= 9 for lookahead assumptions
+                            int[] bd = new int[] { 6 }; // must be <= 9 for lookahead assumptions
+                            int[] tl = new int[1];
+                            int[] td = new int[1];
+
+                            t = table;
+                            t = inftree.inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), blens, bl, bd, tl, td, hufts, _codec);
+
+                            if (t != ZlibConstants.Z_OK)
+                            {
+                                if (t == ZlibConstants.Z_DATA_ERROR)
+                                {
+                                    blens = null;
+                                    mode = InflateBlockMode.BAD;
+                                }
+                                r = t;
+
+                                bitb = b; bitk = k;
+                                _codec.AvailableBytesIn = n;
+                                _codec.TotalBytesIn += p - _codec.NextIn;
+                                _codec.NextIn = p;
+                                writeAt = q;
+                                return Flush(r);
+                            }
+                            codes.Init(bl[0], bd[0], hufts, tl[0], hufts, td[0]);
+                        }
+                        mode = InflateBlockMode.CODES;
+                        goto case InflateBlockMode.CODES;
+
+                    case InflateBlockMode.CODES:
+                        bitb = b; bitk = k;
+                        _codec.AvailableBytesIn = n;
+                        _codec.TotalBytesIn += p - _codec.NextIn;
+                        _codec.NextIn = p;
+                        writeAt = q;
+
+                        r = codes.Process(this, r);
+                        if (r != ZlibConstants.Z_STREAM_END)
+                        {
+                            return Flush(r);
+                        }
+
+                        r = ZlibConstants.Z_OK;
+                        p = _codec.NextIn;
+                        n = _codec.AvailableBytesIn;
+                        b = bitb;
+                        k = bitk;
+                        q = writeAt;
+                        m = (int)(q < readAt ? readAt - q - 1 : end - q);
+
+                        if (last == 0)
+                        {
+                            mode = InflateBlockMode.TYPE;
+                            break;
+                        }
+                        mode = InflateBlockMode.DRY;
+                        goto case InflateBlockMode.DRY;
+
+                    case InflateBlockMode.DRY:
+                        writeAt = q;
+                        r = Flush(r);
+                        q = writeAt; m = (int)(q < readAt ? readAt - q - 1 : end - q);
+                        if (readAt != writeAt)
+                        {
+                            bitb = b; bitk = k;
+                            _codec.AvailableBytesIn = n;
+                            _codec.TotalBytesIn += p - _codec.NextIn;
+                            _codec.NextIn = p;
+                            writeAt = q;
+                            return Flush(r);
+                        }
+                        mode = InflateBlockMode.DONE;
+                        goto case InflateBlockMode.DONE;
+
+                    case InflateBlockMode.DONE:
+                        r = ZlibConstants.Z_STREAM_END;
+                        bitb = b;
+                        bitk = k;
+                        _codec.AvailableBytesIn = n;
+                        _codec.TotalBytesIn += p - _codec.NextIn;
+                        _codec.NextIn = p;
+                        writeAt = q;
+                        return Flush(r);
+
+                    case InflateBlockMode.BAD:
+                        r = ZlibConstants.Z_DATA_ERROR;
+
+                        bitb = b; bitk = k;
+                        _codec.AvailableBytesIn = n;
+                        _codec.TotalBytesIn += p - _codec.NextIn;
+                        _codec.NextIn = p;
+                        writeAt = q;
+                        return Flush(r);
+
+
+                    default:
+                        r = ZlibConstants.Z_STREAM_ERROR;
+
+                        bitb = b; bitk = k;
+                        _codec.AvailableBytesIn = n;
+                        _codec.TotalBytesIn += p - _codec.NextIn;
+                        _codec.NextIn = p;
+                        writeAt = q;
+                        return Flush(r);
+                }
+            }
+        }
+
+
+        internal void Free()
+        {
+            Reset();
+            window = null;
+            hufts = null;
+        }
+
+        internal void SetDictionary(byte[] d, int start, int n)
+        {
+            Array.Copy(d, start, window, 0, n);
+            readAt = writeAt = n;
+        }
+
+        // Returns true if inflate is currently at the end of a block generated
+        // by Z_SYNC_FLUSH or Z_FULL_FLUSH.
+        internal int SyncPoint()
+        {
+            return mode == InflateBlockMode.LENS ? 1 : 0;
+        }
+
+        // copy as much as possible from the sliding window to the output area
+        internal int Flush(int r)
+        {
+            int nBytes;
+
+            for (int pass=0; pass < 2; pass++)
+            {
+                if (pass==0)
+                {
+                    // compute number of bytes to copy as far as end of window
+                    nBytes = (int)((readAt <= writeAt ? writeAt : end) - readAt);
+                }
+                else
+                {
+                    // compute bytes to copy
+                    nBytes = writeAt - readAt;
+                }
+
+                // workitem 8870
+                if (nBytes == 0)
+                {
+                    if (r == ZlibConstants.Z_BUF_ERROR)
+                        r = ZlibConstants.Z_OK;
+                    return r;
+                }
+
+                if (nBytes > _codec.AvailableBytesOut)
+                    nBytes = _codec.AvailableBytesOut;
+
+                if (nBytes != 0 && r == ZlibConstants.Z_BUF_ERROR)
+                    r = ZlibConstants.Z_OK;
+
+                // update counters
+                _codec.AvailableBytesOut -= nBytes;
+                _codec.TotalBytesOut += nBytes;
+
+                // update check information
+                if (checkfn != null)
+                    _codec._Adler32 = check = Adler.Adler32(check, window, readAt, nBytes);
+
+                // copy as far as end of window
+                Array.Copy(window, readAt, _codec.OutputBuffer, _codec.NextOut, nBytes);
+                _codec.NextOut += nBytes;
+                readAt += nBytes;
+
+                // see if more to copy at beginning of window
+                if (readAt == end && pass == 0)
+                {
+                    // wrap pointers
+                    readAt = 0;
+                    if (writeAt == end)
+                        writeAt = 0;
+                }
+                else pass++;
+            }
+
+            // done
+            return r;
+        }
+    }
+
+
+    internal static class InternalInflateConstants
+    {
+        // And'ing with mask[n] masks the lower n bits
+        internal static readonly int[] InflateMask = new int[] {
+            0x00000000, 0x00000001, 0x00000003, 0x00000007,
+            0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
+            0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
+            0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff };
+    }
+
+
+    sealed class InflateCodes
+    {
+        // waiting for "i:"=input,
+        //             "o:"=output,
+        //             "x:"=nothing
+        private const int START   = 0; // x: set up for LEN
+        private const int LEN     = 1; // i: get length/literal/eob next
+        private const int LENEXT  = 2; // i: getting length extra (have base)
+        private const int DIST    = 3; // i: get distance next
+        private const int DISTEXT = 4; // i: getting distance extra
+        private const int COPY    = 5; // o: copying bytes in window, waiting for space
+        private const int LIT     = 6; // o: got literal, waiting for output space
+        private const int WASH    = 7; // o: got eob, possibly still output waiting
+        private const int END     = 8; // x: got eob and all data flushed
+        private const int BADCODE = 9; // x: got error
+
+        internal int mode;        // current inflate_codes mode
+
+        // mode dependent information
+        internal int len;
+
+        internal int[] tree;      // pointer into tree
+        internal int tree_index = 0;
+        internal int need;        // bits needed
+
+        internal int lit;
+
+        // if EXT or COPY, where and how much
+        internal int bitsToGet;   // bits to get for extra
+        internal int dist;        // distance back to copy from
+
+        internal byte lbits;      // ltree bits decoded per branch
+        internal byte dbits;      // dtree bits decoder per branch
+        internal int[] ltree;     // literal/length/eob tree
+        internal int ltree_index; // literal/length/eob tree
+        internal int[] dtree;     // distance tree
+        internal int dtree_index; // distance tree
+
+        internal InflateCodes()
+        {
+        }
+
+        internal void Init(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index)
+        {
+            mode = START;
+            lbits = (byte)bl;
+            dbits = (byte)bd;
+            ltree = tl;
+            ltree_index = tl_index;
+            dtree = td;
+            dtree_index = td_index;
+            tree = null;
+        }
+
+        internal int Process(InflateBlocks blocks, int r)
+        {
+            int j;      // temporary storage
+            int tindex; // temporary pointer
+            int e;      // extra bits or operation
+            int b = 0;  // bit buffer
+            int k = 0;  // bits in bit buffer
+            int p = 0;  // input data pointer
+            int n;      // bytes available there
+            int q;      // output window write pointer
+            int m;      // bytes to end of window or read pointer
+            int f;      // pointer to copy strings from
+
+            ZlibCodec z = blocks._codec;
+
+            // copy input/output information to locals (UPDATE macro restores)
+            p = z.NextIn;
+            n = z.AvailableBytesIn;
+            b = blocks.bitb;
+            k = blocks.bitk;
+            q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+
+            // process input and output based on current state
+            while (true)
+            {
+                switch (mode)
+                {
+                    // waiting for "i:"=input, "o:"=output, "x:"=nothing
+                    case START:  // x: set up for LEN
+                        if (m >= 258 && n >= 10)
+                        {
+                            blocks.bitb = b; blocks.bitk = k;
+                            z.AvailableBytesIn = n;
+                            z.TotalBytesIn += p - z.NextIn;
+                            z.NextIn = p;
+                            blocks.writeAt = q;
+                            r = InflateFast(lbits, dbits, ltree, ltree_index, dtree, dtree_index, blocks, z);
+
+                            p = z.NextIn;
+                            n = z.AvailableBytesIn;
+                            b = blocks.bitb;
+                            k = blocks.bitk;
+                            q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+
+                            if (r != ZlibConstants.Z_OK)
+                            {
+                                mode = (r == ZlibConstants.Z_STREAM_END) ? WASH : BADCODE;
+                                break;
+                            }
+                        }
+                        need = lbits;
+                        tree = ltree;
+                        tree_index = ltree_index;
+
+                        mode = LEN;
+                        goto case LEN;
+
+                    case LEN:  // i: get length/literal/eob next
+                        j = need;
+
+                        while (k < j)
+                        {
+                            if (n != 0)
+                                r = ZlibConstants.Z_OK;
+                            else
+                            {
+                                blocks.bitb = b; blocks.bitk = k;
+                                z.AvailableBytesIn = n;
+                                z.TotalBytesIn += p - z.NextIn;
+                                z.NextIn = p;
+                                blocks.writeAt = q;
+                                return blocks.Flush(r);
+                            }
+                            n--;
+                            b |= (z.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+
+                        tindex = (tree_index + (b & InternalInflateConstants.InflateMask[j])) * 3;
+
+                        b >>= (tree[tindex + 1]);
+                        k -= (tree[tindex + 1]);
+
+                        e = tree[tindex];
+
+                        if (e == 0)
+                        {
+                            // literal
+                            lit = tree[tindex + 2];
+                            mode = LIT;
+                            break;
+                        }
+                        if ((e & 16) != 0)
+                        {
+                            // length
+                            bitsToGet = e & 15;
+                            len = tree[tindex + 2];
+                            mode = LENEXT;
+                            break;
+                        }
+                        if ((e & 64) == 0)
+                        {
+                            // next table
+                            need = e;
+                            tree_index = tindex / 3 + tree[tindex + 2];
+                            break;
+                        }
+                        if ((e & 32) != 0)
+                        {
+                            // end of block
+                            mode = WASH;
+                            break;
+                        }
+                        mode = BADCODE; // invalid code
+                        z.Message = "invalid literal/length code";
+                        r = ZlibConstants.Z_DATA_ERROR;
+
+                        blocks.bitb = b; blocks.bitk = k;
+                        z.AvailableBytesIn = n;
+                        z.TotalBytesIn += p - z.NextIn;
+                        z.NextIn = p;
+                        blocks.writeAt = q;
+                        return blocks.Flush(r);
+
+
+                    case LENEXT:  // i: getting length extra (have base)
+                        j = bitsToGet;
+
+                        while (k < j)
+                        {
+                            if (n != 0)
+                                r = ZlibConstants.Z_OK;
+                            else
+                            {
+                                blocks.bitb = b; blocks.bitk = k;
+                                z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                                blocks.writeAt = q;
+                                return blocks.Flush(r);
+                            }
+                            n--; b |= (z.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+
+                        len += (b & InternalInflateConstants.InflateMask[j]);
+
+                        b >>= j;
+                        k -= j;
+
+                        need = dbits;
+                        tree = dtree;
+                        tree_index = dtree_index;
+                        mode = DIST;
+                        goto case DIST;
+
+                    case DIST:  // i: get distance next
+                        j = need;
+
+                        while (k < j)
+                        {
+                            if (n != 0)
+                                r = ZlibConstants.Z_OK;
+                            else
+                            {
+                                blocks.bitb = b; blocks.bitk = k;
+                                z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                                blocks.writeAt = q;
+                                return blocks.Flush(r);
+                            }
+                            n--; b |= (z.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+
+                        tindex = (tree_index + (b & InternalInflateConstants.InflateMask[j])) * 3;
+
+                        b >>= tree[tindex + 1];
+                        k -= tree[tindex + 1];
+
+                        e = (tree[tindex]);
+                        if ((e & 0x10) != 0)
+                        {
+                            // distance
+                            bitsToGet = e & 15;
+                            dist = tree[tindex + 2];
+                            mode = DISTEXT;
+                            break;
+                        }
+                        if ((e & 64) == 0)
+                        {
+                            // next table
+                            need = e;
+                            tree_index = tindex / 3 + tree[tindex + 2];
+                            break;
+                        }
+                        mode = BADCODE; // invalid code
+                        z.Message = "invalid distance code";
+                        r = ZlibConstants.Z_DATA_ERROR;
+
+                        blocks.bitb = b; blocks.bitk = k;
+                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                        blocks.writeAt = q;
+                        return blocks.Flush(r);
+
+
+                    case DISTEXT:  // i: getting distance extra
+                        j = bitsToGet;
+
+                        while (k < j)
+                        {
+                            if (n != 0)
+                                r = ZlibConstants.Z_OK;
+                            else
+                            {
+                                blocks.bitb = b; blocks.bitk = k;
+                                z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                                blocks.writeAt = q;
+                                return blocks.Flush(r);
+                            }
+                            n--; b |= (z.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+
+                        dist += (b & InternalInflateConstants.InflateMask[j]);
+
+                        b >>= j;
+                        k -= j;
+
+                        mode = COPY;
+                        goto case COPY;
+
+                    case COPY:  // o: copying bytes in window, waiting for space
+                        f = q - dist;
+                        while (f < 0)
+                        {
+                            // modulo window size-"while" instead
+                            f += blocks.end; // of "if" handles invalid distances
+                        }
+                        while (len != 0)
+                        {
+                            if (m == 0)
+                            {
+                                if (q == blocks.end && blocks.readAt != 0)
+                                {
+                                    q = 0; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+                                }
+                                if (m == 0)
+                                {
+                                    blocks.writeAt = q; r = blocks.Flush(r);
+                                    q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+
+                                    if (q == blocks.end && blocks.readAt != 0)
+                                    {
+                                        q = 0; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+                                    }
+
+                                    if (m == 0)
+                                    {
+                                        blocks.bitb = b; blocks.bitk = k;
+                                        z.AvailableBytesIn = n;
+                                        z.TotalBytesIn += p - z.NextIn;
+                                        z.NextIn = p;
+                                        blocks.writeAt = q;
+                                        return blocks.Flush(r);
+                                    }
+                                }
+                            }
+
+                            blocks.window[q++] = blocks.window[f++]; m--;
+
+                            if (f == blocks.end)
+                                f = 0;
+                            len--;
+                        }
+                        mode = START;
+                        break;
+
+                    case LIT:  // o: got literal, waiting for output space
+                        if (m == 0)
+                        {
+                            if (q == blocks.end && blocks.readAt != 0)
+                            {
+                                q = 0; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+                            }
+                            if (m == 0)
+                            {
+                                blocks.writeAt = q; r = blocks.Flush(r);
+                                q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+
+                                if (q == blocks.end && blocks.readAt != 0)
+                                {
+                                    q = 0; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+                                }
+                                if (m == 0)
+                                {
+                                    blocks.bitb = b; blocks.bitk = k;
+                                    z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                                    blocks.writeAt = q;
+                                    return blocks.Flush(r);
+                                }
+                            }
+                        }
+                        r = ZlibConstants.Z_OK;
+
+                        blocks.window[q++] = (byte)lit; m--;
+
+                        mode = START;
+                        break;
+
+                    case WASH:  // o: got eob, possibly more output
+                        if (k > 7)
+                        {
+                            // return unused byte, if any
+                            k -= 8;
+                            n++;
+                            p--; // can always return one
+                        }
+
+                        blocks.writeAt = q; r = blocks.Flush(r);
+                        q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+
+                        if (blocks.readAt != blocks.writeAt)
+                        {
+                            blocks.bitb = b; blocks.bitk = k;
+                            z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                            blocks.writeAt = q;
+                            return blocks.Flush(r);
+                        }
+                        mode = END;
+                        goto case END;
+
+                    case END:
+                        r = ZlibConstants.Z_STREAM_END;
+                        blocks.bitb = b; blocks.bitk = k;
+                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                        blocks.writeAt = q;
+                        return blocks.Flush(r);
+
+                    case BADCODE:  // x: got error
+
+                        r = ZlibConstants.Z_DATA_ERROR;
+
+                        blocks.bitb = b; blocks.bitk = k;
+                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                        blocks.writeAt = q;
+                        return blocks.Flush(r);
+
+                    default:
+                        r = ZlibConstants.Z_STREAM_ERROR;
+
+                        blocks.bitb = b; blocks.bitk = k;
+                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                        blocks.writeAt = q;
+                        return blocks.Flush(r);
+                }
+            }
+        }
+
+
+        // Called with number of bytes left to write in window at least 258
+        // (the maximum string length) and number of input bytes available
+        // at least ten.  The ten bytes are six bytes for the longest length/
+        // distance pair plus four bytes for overloading the bit buffer.
+
+        internal int InflateFast(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index, InflateBlocks s, ZlibCodec z)
+        {
+            int t;        // temporary pointer
+            int[] tp;     // temporary pointer
+            int tp_index; // temporary pointer
+            int e;        // extra bits or operation
+            int b;        // bit buffer
+            int k;        // bits in bit buffer
+            int p;        // input data pointer
+            int n;        // bytes available there
+            int q;        // output window write pointer
+            int m;        // bytes to end of window or read pointer
+            int ml;       // mask for literal/length tree
+            int md;       // mask for distance tree
+            int c;        // bytes to copy
+            int d;        // distance back to copy from
+            int r;        // copy source pointer
+
+            int tp_index_t_3; // (tp_index+t)*3
+
+            // load input, output, bit values
+            p = z.NextIn; n = z.AvailableBytesIn; b = s.bitb; k = s.bitk;
+            q = s.writeAt; m = q < s.readAt ? s.readAt - q - 1 : s.end - q;
+
+            // initialize masks
+            ml = InternalInflateConstants.InflateMask[bl];
+            md = InternalInflateConstants.InflateMask[bd];
+
+            // do until not enough input or output space for fast loop
+            do
+            {
+                // assume called with m >= 258 && n >= 10
+                // get literal/length code
+                while (k < (20))
+                {
+                    // max bits for literal/length code
+                    n--;
+                    b |= (z.InputBuffer[p++] & 0xff) << k; k += 8;
+                }
+
+                t = b & ml;
+                tp = tl;
+                tp_index = tl_index;
+                tp_index_t_3 = (tp_index + t) * 3;
+                if ((e = tp[tp_index_t_3]) == 0)
+                {
+                    b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
+
+                    s.window[q++] = (byte)tp[tp_index_t_3 + 2];
+                    m--;
+                    continue;
+                }
+                do
+                {
+
+                    b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
+
+                    if ((e & 16) != 0)
+                    {
+                        e &= 15;
+                        c = tp[tp_index_t_3 + 2] + ((int)b & InternalInflateConstants.InflateMask[e]);
+
+                        b >>= e; k -= e;
+
+                        // decode distance base of block to copy
+                        while (k < 15)
+                        {
+                            // max bits for distance code
+                            n--;
+                            b |= (z.InputBuffer[p++] & 0xff) << k; k += 8;
+                        }
+
+                        t = b & md;
+                        tp = td;
+                        tp_index = td_index;
+                        tp_index_t_3 = (tp_index + t) * 3;
+                        e = tp[tp_index_t_3];
+
+                        do
+                        {
+
+                            b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
+
+                            if ((e & 16) != 0)
+                            {
+                                // get extra bits to add to distance base
+                                e &= 15;
+                                while (k < e)
+                                {
+                                    // get extra bits (up to 13)
+                                    n--;
+                                    b |= (z.InputBuffer[p++] & 0xff) << k; k += 8;
+                                }
+
+                                d = tp[tp_index_t_3 + 2] + (b & InternalInflateConstants.InflateMask[e]);
+
+                                b >>= e; k -= e;
+
+                                // do the copy
+                                m -= c;
+                                if (q >= d)
+                                {
+                                    // offset before dest
+                                    //  just copy
+                                    r = q - d;
+                                    if (q - r > 0 && 2 > (q - r))
+                                    {
+                                        s.window[q++] = s.window[r++]; // minimum count is three,
+                                        s.window[q++] = s.window[r++]; // so unroll loop a little
+                                        c -= 2;
+                                    }
+                                    else
+                                    {
+                                        Array.Copy(s.window, r, s.window, q, 2);
+                                        q += 2; r += 2; c -= 2;
+                                    }
+                                }
+                                else
+                                {
+                                    // else offset after destination
+                                    r = q - d;
+                                    do
+                                    {
+                                        r += s.end; // force pointer in window
+                                    }
+                                    while (r < 0); // covers invalid distances
+                                    e = s.end - r;
+                                    if (c > e)
+                                    {
+                                        // if source crosses,
+                                        c -= e; // wrapped copy
+                                        if (q - r > 0 && e > (q - r))
+                                        {
+                                            do
+                                            {
+                                                s.window[q++] = s.window[r++];
+                                            }
+                                            while (--e != 0);
+                                        }
+                                        else
+                                        {
+                                            Array.Copy(s.window, r, s.window, q, e);
+                                            q += e; r += e; e = 0;
+                                        }
+                                        r = 0; // copy rest from start of window
+                                    }
+                                }
+
+                                // copy all or what's left
+                                if (q - r > 0 && c > (q - r))
+                                {
+                                    do
+                                    {
+                                        s.window[q++] = s.window[r++];
+                                    }
+                                    while (--c != 0);
+                                }
+                                else
+                                {
+                                    Array.Copy(s.window, r, s.window, q, c);
+                                    q += c; r += c; c = 0;
+                                }
+                                break;
+                            }
+                            else if ((e & 64) == 0)
+                            {
+                                t += tp[tp_index_t_3 + 2];
+                                t += (b & InternalInflateConstants.InflateMask[e]);
+                                tp_index_t_3 = (tp_index + t) * 3;
+                                e = tp[tp_index_t_3];
+                            }
+                            else
+                            {
+                                z.Message = "invalid distance code";
+
+                                c = z.AvailableBytesIn - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= (c << 3);
+
+                                s.bitb = b; s.bitk = k;
+                                z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                                s.writeAt = q;
+
+                                return ZlibConstants.Z_DATA_ERROR;
+                            }
+                        }
+                        while (true);
+                        break;
+                    }
+
+                    if ((e & 64) == 0)
+                    {
+                        t += tp[tp_index_t_3 + 2];
+                        t += (b & InternalInflateConstants.InflateMask[e]);
+                        tp_index_t_3 = (tp_index + t) * 3;
+                        if ((e = tp[tp_index_t_3]) == 0)
+                        {
+                            b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
+                            s.window[q++] = (byte)tp[tp_index_t_3 + 2];
+                            m--;
+                            break;
+                        }
+                    }
+                    else if ((e & 32) != 0)
+                    {
+                        c = z.AvailableBytesIn - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= (c << 3);
+
+                        s.bitb = b; s.bitk = k;
+                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                        s.writeAt = q;
+
+                        return ZlibConstants.Z_STREAM_END;
+                    }
+                    else
+                    {
+                        z.Message = "invalid literal/length code";
+
+                        c = z.AvailableBytesIn - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= (c << 3);
+
+                        s.bitb = b; s.bitk = k;
+                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                        s.writeAt = q;
+
+                        return ZlibConstants.Z_DATA_ERROR;
+                    }
+                }
+                while (true);
+            }
+            while (m >= 258 && n >= 10);
+
+            // not enough input or output--restore pointers and return
+            c = z.AvailableBytesIn - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= (c << 3);
+
+            s.bitb = b; s.bitk = k;
+            z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+            s.writeAt = q;
+
+            return ZlibConstants.Z_OK;
+        }
+    }
+
+
+    internal sealed class InflateManager
+    {
+        // preset dictionary flag in zlib header
+        private const int PRESET_DICT = 0x20;
+
+        private const int Z_DEFLATED = 8;
+
+        private enum InflateManagerMode
+        {
+            METHOD = 0,  // waiting for method byte
+            FLAG   = 1,  // waiting for flag byte
+            DICT4  = 2,  // four dictionary check bytes to go
+            DICT3  = 3,  // three dictionary check bytes to go
+            DICT2  = 4,  // two dictionary check bytes to go
+            DICT1  = 5,  // one dictionary check byte to go
+            DICT0  = 6,  // waiting for inflateSetDictionary
+            BLOCKS = 7,  // decompressing blocks
+            CHECK4 = 8,  // four check bytes to go
+            CHECK3 = 9,  // three check bytes to go
+            CHECK2 = 10, // two check bytes to go
+            CHECK1 = 11, // one check byte to go
+            DONE   = 12, // finished check, done
+            BAD    = 13, // got an error--stay here
+        }
+
+        private InflateManagerMode mode; // current inflate mode
+        internal ZlibCodec _codec; // pointer back to this zlib stream
+
+        // mode dependent information
+        internal int method; // if FLAGS, method byte
+
+        // if CHECK, check values to compare
+        internal uint computedCheck; // computed check value
+        internal uint expectedCheck; // stream check value
+
+        // if BAD, inflateSync's marker bytes count
+        internal int marker;
+
+        // mode independent information
+        //internal int nowrap; // flag for no wrapper
+        private bool _handleRfc1950HeaderBytes = true;
+        internal bool HandleRfc1950HeaderBytes
+        {
+            get { return _handleRfc1950HeaderBytes; }
+            set { _handleRfc1950HeaderBytes = value; }
+        }
+        internal int wbits; // log2(window size)  (8..15, defaults to 15)
+
+        internal InflateBlocks blocks; // current inflate_blocks state
+
+        public InflateManager() { }
+
+        public InflateManager(bool expectRfc1950HeaderBytes)
+        {
+            _handleRfc1950HeaderBytes = expectRfc1950HeaderBytes;
+        }
+
+        internal int Reset()
+        {
+            _codec.TotalBytesIn = _codec.TotalBytesOut = 0;
+            _codec.Message = null;
+            mode = HandleRfc1950HeaderBytes ? InflateManagerMode.METHOD : InflateManagerMode.BLOCKS;
+            blocks.Reset();
+            return ZlibConstants.Z_OK;
+        }
+
+        internal int End()
+        {
+            if (blocks != null)
+                blocks.Free();
+            blocks = null;
+            return ZlibConstants.Z_OK;
+        }
+
+        internal int Initialize(ZlibCodec codec, int w)
+        {
+            _codec = codec;
+            _codec.Message = null;
+            blocks = null;
+
+            // handle undocumented nowrap option (no zlib header or check)
+            //nowrap = 0;
+            //if (w < 0)
+            //{
+            //    w = - w;
+            //    nowrap = 1;
+            //}
+
+            // set window size
+            if (w < 8 || w > 15)
+            {
+                End();
+                throw new ZlibException("Bad window size.");
+
+                //return ZlibConstants.Z_STREAM_ERROR;
+            }
+            wbits = w;
+
+            blocks = new InflateBlocks(codec,
+                HandleRfc1950HeaderBytes ? this : null,
+                1 << w);
+
+            // reset state
+            Reset();
+            return ZlibConstants.Z_OK;
+        }
+
+
+        internal int Inflate(FlushType flush)
+        {
+            int b;
+
+            if (_codec.InputBuffer == null)
+                throw new ZlibException("InputBuffer is null. ");
+
+//             int f = (flush == FlushType.Finish)
+//                 ? ZlibConstants.Z_BUF_ERROR
+//                 : ZlibConstants.Z_OK;
+
+            // workitem 8870
+            int f = ZlibConstants.Z_OK;
+            int r = ZlibConstants.Z_BUF_ERROR;
+
+            while (true)
+            {
+                switch (mode)
+                {
+                    case InflateManagerMode.METHOD:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        if (((method = _codec.InputBuffer[_codec.NextIn++]) & 0xf) != Z_DEFLATED)
+                        {
+                            mode = InflateManagerMode.BAD;
+                            _codec.Message = String.Format("unknown compression method (0x{0:X2})", method);
+                            marker = 5; // can't try inflateSync
+                            break;
+                        }
+                        if ((method >> 4) + 8 > wbits)
+                        {
+                            mode = InflateManagerMode.BAD;
+                            _codec.Message = String.Format("invalid window size ({0})", (method >> 4) + 8);
+                            marker = 5; // can't try inflateSync
+                            break;
+                        }
+                        mode = InflateManagerMode.FLAG;
+                        break;
+
+
+                    case InflateManagerMode.FLAG:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        b = (_codec.InputBuffer[_codec.NextIn++]) & 0xff;
+
+                        if ((((method << 8) + b) % 31) != 0)
+                        {
+                            mode = InflateManagerMode.BAD;
+                            _codec.Message = "incorrect header check";
+                            marker = 5; // can't try inflateSync
+                            break;
+                        }
+
+                        mode = ((b & PRESET_DICT) == 0)
+                            ? InflateManagerMode.BLOCKS
+                            : InflateManagerMode.DICT4;
+                        break;
+
+                    case InflateManagerMode.DICT4:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        expectedCheck = (uint)((_codec.InputBuffer[_codec.NextIn++] << 24) & 0xff000000);
+                        mode = InflateManagerMode.DICT3;
+                        break;
+
+                    case InflateManagerMode.DICT3:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 16) & 0x00ff0000);
+                        mode = InflateManagerMode.DICT2;
+                        break;
+
+                    case InflateManagerMode.DICT2:
+
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 8) & 0x0000ff00);
+                        mode = InflateManagerMode.DICT1;
+                        break;
+
+
+                    case InflateManagerMode.DICT1:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--; _codec.TotalBytesIn++;
+                        expectedCheck += (uint)(_codec.InputBuffer[_codec.NextIn++] & 0x000000ff);
+                        _codec._Adler32 = expectedCheck;
+                        mode = InflateManagerMode.DICT0;
+                        return ZlibConstants.Z_NEED_DICT;
+
+
+                    case InflateManagerMode.DICT0:
+                        mode = InflateManagerMode.BAD;
+                        _codec.Message = "need dictionary";
+                        marker = 0; // can try inflateSync
+                        return ZlibConstants.Z_STREAM_ERROR;
+
+
+                    case InflateManagerMode.BLOCKS:
+                        r = blocks.Process(r);
+                        if (r == ZlibConstants.Z_DATA_ERROR)
+                        {
+                            mode = InflateManagerMode.BAD;
+                            marker = 0; // can try inflateSync
+                            break;
+                        }
+
+                        if (r == ZlibConstants.Z_OK) r = f;
+
+                        if (r != ZlibConstants.Z_STREAM_END)
+                            return r;
+
+                        r = f;
+                        computedCheck = blocks.Reset();
+                        if (!HandleRfc1950HeaderBytes)
+                        {
+                            mode = InflateManagerMode.DONE;
+                            return ZlibConstants.Z_STREAM_END;
+                        }
+                        mode = InflateManagerMode.CHECK4;
+                        break;
+
+                    case InflateManagerMode.CHECK4:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        expectedCheck = (uint)((_codec.InputBuffer[_codec.NextIn++] << 24) & 0xff000000);
+                        mode = InflateManagerMode.CHECK3;
+                        break;
+
+                    case InflateManagerMode.CHECK3:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--; _codec.TotalBytesIn++;
+                        expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 16) & 0x00ff0000);
+                        mode = InflateManagerMode.CHECK2;
+                        break;
+
+                    case InflateManagerMode.CHECK2:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 8) & 0x0000ff00);
+                        mode = InflateManagerMode.CHECK1;
+                        break;
+
+                    case InflateManagerMode.CHECK1:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--; _codec.TotalBytesIn++;
+                        expectedCheck += (uint)(_codec.InputBuffer[_codec.NextIn++] & 0x000000ff);
+                        if (computedCheck != expectedCheck)
+                        {
+                            mode = InflateManagerMode.BAD;
+                            _codec.Message = "incorrect data check";
+                            marker = 5; // can't try inflateSync
+                            break;
+                        }
+                        mode = InflateManagerMode.DONE;
+                        return ZlibConstants.Z_STREAM_END;
+
+                    case InflateManagerMode.DONE:
+                        return ZlibConstants.Z_STREAM_END;
+
+                    case InflateManagerMode.BAD:
+                        throw new ZlibException(String.Format("Bad state ({0})", _codec.Message));
+
+                    default:
+                        throw new ZlibException("Stream error.");
+
+                }
+            }
+        }
+
+
+
+        internal int SetDictionary(byte[] dictionary)
+        {
+            int index = 0;
+            int length = dictionary.Length;
+            if (mode != InflateManagerMode.DICT0)
+                throw new ZlibException("Stream error.");
+
+            if (Adler.Adler32(1, dictionary, 0, dictionary.Length) != _codec._Adler32)
+            {
+                return ZlibConstants.Z_DATA_ERROR;
+            }
+
+            _codec._Adler32 = Adler.Adler32(0, null, 0, 0);
+
+            if (length >= (1 << wbits))
+            {
+                length = (1 << wbits) - 1;
+                index = dictionary.Length - length;
+            }
+            blocks.SetDictionary(dictionary, index, length);
+            mode = InflateManagerMode.BLOCKS;
+            return ZlibConstants.Z_OK;
+        }
+
+
+        private static readonly byte[] mark = new byte[] { 0, 0, 0xff, 0xff };
+
+        internal int Sync()
+        {
+            int n; // number of bytes to look at
+            int p; // pointer to bytes
+            int m; // number of marker bytes found in a row
+            long r, w; // temporaries to save total_in and total_out
+
+            // set up
+            if (mode != InflateManagerMode.BAD)
+            {
+                mode = InflateManagerMode.BAD;
+                marker = 0;
+            }
+            if ((n = _codec.AvailableBytesIn) == 0)
+                return ZlibConstants.Z_BUF_ERROR;
+            p = _codec.NextIn;
+            m = marker;
+
+            // search
+            while (n != 0 && m < 4)
+            {
+                if (_codec.InputBuffer[p] == mark[m])
+                {
+                    m++;
+                }
+                else if (_codec.InputBuffer[p] != 0)
+                {
+                    m = 0;
+                }
+                else
+                {
+                    m = 4 - m;
+                }
+                p++; n--;
+            }
+
+            // restore
+            _codec.TotalBytesIn += p - _codec.NextIn;
+            _codec.NextIn = p;
+            _codec.AvailableBytesIn = n;
+            marker = m;
+
+            // return no joy or set up to restart on a new block
+            if (m != 4)
+            {
+                return ZlibConstants.Z_DATA_ERROR;
+            }
+            r = _codec.TotalBytesIn;
+            w = _codec.TotalBytesOut;
+            Reset();
+            _codec.TotalBytesIn = r;
+            _codec.TotalBytesOut = w;
+            mode = InflateManagerMode.BLOCKS;
+            return ZlibConstants.Z_OK;
+        }
+
+
+        // Returns true if inflate is currently at the end of a block generated
+        // by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
+        // implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH
+        // but removes the length bytes of the resulting empty stored block. When
+        // decompressing, PPP checks that at the end of input packet, inflate is
+        // waiting for these length bytes.
+        internal int SyncPoint(ZlibCodec z)
+        {
+            return blocks.SyncPoint();
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Deflate/Tree.cs b/MonoGame.Framework/Utilities/Deflate/Tree.cs
new file mode 100644
index 00000000000..7e4f9f77d21
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Deflate/Tree.cs
@@ -0,0 +1,423 @@
+// Tree.cs
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.  
+// All rights reserved.
+//
+// This code module is part of DotNetZip, a zipfile class library.
+//
+// ------------------------------------------------------------------
+//
+// This code is licensed under the Microsoft Public License. 
+// See the file License.txt for the license details.
+// More info on: http://dotnetzip.codeplex.com
+//
+// ------------------------------------------------------------------
+//
+// last saved (in emacs): 
+// Time-stamp: <2009-October-28 13:29:50>
+//
+// ------------------------------------------------------------------
+//
+// This module defines classes for zlib compression and
+// decompression. This code is derived from the jzlib implementation of
+// zlib. In keeping with the license for jzlib, the copyright to that
+// code is below.
+//
+// ------------------------------------------------------------------
+// 
+// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright 
+// notice, this list of conditions and the following disclaimer in 
+// the documentation and/or other materials provided with the distribution.
+// 
+// 3. The names of the authors may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+// -----------------------------------------------------------------------
+//
+// This program is based on zlib-1.1.3; credit to authors
+// Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+// and contributors of zlib.
+//
+// -----------------------------------------------------------------------
+
+
+using System;
+
+namespace MonoGame.Utilities.Deflate
+{
+    sealed class Tree
+    {
+        private static readonly int HEAP_SIZE = (2 * InternalConstants.L_CODES + 1);
+                
+        // extra bits for each length code
+        internal static readonly int[] ExtraLengthBits = new int[]
+        {
+            0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+            3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
+        };
+                
+        // extra bits for each distance code
+        internal static readonly int[] ExtraDistanceBits = new int[]
+        {
+            0, 0, 0, 0, 1, 1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  6,
+            7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13
+        };
+                
+        // extra bits for each bit length code
+        internal static readonly int[] extra_blbits = new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7};
+                
+        internal static readonly sbyte[] bl_order = new sbyte[]{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+                
+                
+        // The lengths of the bit length codes are sent in order of decreasing
+        // probability, to avoid transmitting the lengths for unused bit
+        // length codes.
+                
+        internal const int Buf_size = 8 * 2;
+                
+        // see definition of array dist_code below
+        //internal const int DIST_CODE_LEN = 512;
+                
+        private static readonly sbyte[] _dist_code = new sbyte[]
+        {
+            0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7, 
+            8,  8,  8,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9,
+            10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
+            11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 
+            12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 
+            12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 
+            13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
+            13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
+            14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+            14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+            14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+            14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+            15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+            15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+            15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+            15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+            0,   0, 16, 17, 18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 
+            22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 
+            24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+            25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 
+            26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 
+            26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 
+            27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 
+            27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 
+            28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
+            28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
+            28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
+            28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
+            29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
+            29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
+            29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
+            29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+        };
+                
+        internal static readonly sbyte[] LengthCode = new sbyte[]
+        {
+            0,   1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11,
+            12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15,
+            16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17,
+            18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19,
+            20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+            21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+            22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+            23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+            24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+            24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+            25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+            25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+            26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+            26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+            27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+            27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+        };
+                
+
+        internal static readonly int[] LengthBase = new int[]
+        {
+            0,   1,  2,  3,  4,  5,  6,   7,   8,  10,  12,  14, 16, 20, 24, 28,
+            32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 0
+        };
+                
+
+        internal static readonly int[] DistanceBase = new int[]
+        {
+            0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192,
+            256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576
+        };
+
+        
+        /// <summary>
+        /// Map from a distance to a distance code.
+        /// </summary>
+        /// <remarks> 
+        /// No side effects. _dist_code[256] and _dist_code[257] are never used.
+        /// </remarks>
+        internal static int DistanceCode(int dist)
+        {
+            return (dist < 256)
+                ? _dist_code[dist]
+                : _dist_code[256 + SharedUtils.URShift(dist, 7)];
+        }
+
+        internal short[] dyn_tree; // the dynamic tree
+        internal int max_code; // largest code with non zero frequency
+        internal StaticTree staticTree; // the corresponding static tree
+                
+        // Compute the optimal bit lengths for a tree and update the total bit length
+        // for the current block.
+        // IN assertion: the fields freq and dad are set, heap[heap_max] and
+        //    above are the tree nodes sorted by increasing frequency.
+        // OUT assertions: the field len is set to the optimal bit length, the
+        //     array bl_count contains the frequencies for each bit length.
+        //     The length opt_len is updated; static_len is also updated if stree is
+        //     not null.
+        internal void  gen_bitlen(DeflateManager s)
+        {
+            short[] tree = dyn_tree;
+            short[] stree = staticTree.treeCodes;
+            int[] extra = staticTree.extraBits;
+            int base_Renamed = staticTree.extraBase;
+            int max_length = staticTree.maxLength;
+            int h; // heap index
+            int n, m; // iterate over the tree elements
+            int bits; // bit length
+            int xbits; // extra bits
+            short f; // frequency
+            int overflow = 0; // number of elements with bit length too large
+                        
+            for (bits = 0; bits <= InternalConstants.MAX_BITS; bits++)
+                s.bl_count[bits] = 0;
+                        
+            // In a first pass, compute the optimal bit lengths (which may
+            // overflow in the case of the bit length tree).
+            tree[s.heap[s.heap_max] * 2 + 1] = 0; // root of the heap
+                        
+            for (h = s.heap_max + 1; h < HEAP_SIZE; h++)
+            {
+                n = s.heap[h];
+                bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;
+                if (bits > max_length)
+                {
+                    bits = max_length; overflow++;
+                }
+                tree[n * 2 + 1] = (short) bits;
+                // We overwrite tree[n*2+1] which is no longer needed
+                                
+                if (n > max_code)
+                    continue; // not a leaf node
+                                
+                s.bl_count[bits]++;
+                xbits = 0;
+                if (n >= base_Renamed)
+                    xbits = extra[n - base_Renamed];
+                f = tree[n * 2];
+                s.opt_len += f * (bits + xbits);
+                if (stree != null)
+                    s.static_len += f * (stree[n * 2 + 1] + xbits);
+            }
+            if (overflow == 0)
+                return ;
+                        
+            // This happens for example on obj2 and pic of the Calgary corpus
+            // Find the first bit length which could increase:
+            do 
+            {
+                bits = max_length - 1;
+                while (s.bl_count[bits] == 0)
+                    bits--;
+                s.bl_count[bits]--; // move one leaf down the tree
+                s.bl_count[bits + 1] = (short) (s.bl_count[bits + 1] + 2); // move one overflow item as its brother
+                s.bl_count[max_length]--;
+                // The brother of the overflow item also moves one step up,
+                // but this does not affect bl_count[max_length]
+                overflow -= 2;
+            }
+            while (overflow > 0);
+                        
+            for (bits = max_length; bits != 0; bits--)
+            {
+                n = s.bl_count[bits];
+                while (n != 0)
+                {
+                    m = s.heap[--h];
+                    if (m > max_code)
+                        continue;
+                    if (tree[m * 2 + 1] != bits)
+                    {
+                        s.opt_len = (int) (s.opt_len + ((long) bits - (long) tree[m * 2 + 1]) * (long) tree[m * 2]);
+                        tree[m * 2 + 1] = (short) bits;
+                    }
+                    n--;
+                }
+            }
+        }
+                
+        // Construct one Huffman tree and assigns the code bit strings and lengths.
+        // Update the total bit length for the current block.
+        // IN assertion: the field freq is set for all tree elements.
+        // OUT assertions: the fields len and code are set to the optimal bit length
+        //     and corresponding code. The length opt_len is updated; static_len is
+        //     also updated if stree is not null. The field max_code is set.
+        internal void  build_tree(DeflateManager s)
+        {
+            short[] tree  = dyn_tree;
+            short[] stree = staticTree.treeCodes;
+            int elems     = staticTree.elems;
+            int n, m;            // iterate over heap elements
+            int max_code  = -1;  // largest code with non zero frequency
+            int node;            // new node being created
+                        
+            // Construct the initial heap, with least frequent element in
+            // heap[1]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
+            // heap[0] is not used.
+            s.heap_len = 0;
+            s.heap_max = HEAP_SIZE;
+                        
+            for (n = 0; n < elems; n++)
+            {
+                if (tree[n * 2] != 0)
+                {
+                    s.heap[++s.heap_len] = max_code = n;
+                    s.depth[n] = 0;
+                }
+                else
+                {
+                    tree[n * 2 + 1] = 0;
+                }
+            }
+                        
+            // The pkzip format requires that at least one distance code exists,
+            // and that at least one bit should be sent even if there is only one
+            // possible code. So to avoid special checks later on we force at least
+            // two codes of non zero frequency.
+            while (s.heap_len < 2)
+            {
+                node = s.heap[++s.heap_len] = (max_code < 2?++max_code:0);
+                tree[node * 2] = 1;
+                s.depth[node] = 0;
+                s.opt_len--;
+                if (stree != null)
+                    s.static_len -= stree[node * 2 + 1];
+                // node is 0 or 1 so it does not have extra bits
+            }
+            this.max_code = max_code;
+                        
+            // The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
+            // establish sub-heaps of increasing lengths:
+                        
+            for (n = s.heap_len / 2; n >= 1; n--)
+                s.pqdownheap(tree, n);
+                        
+            // Construct the Huffman tree by repeatedly combining the least two
+            // frequent nodes.
+                        
+            node = elems; // next internal node of the tree
+            do 
+            {
+                // n = node of least frequency
+                n = s.heap[1];
+                s.heap[1] = s.heap[s.heap_len--];
+                s.pqdownheap(tree, 1);
+                m = s.heap[1]; // m = node of next least frequency
+                                
+                s.heap[--s.heap_max] = n; // keep the nodes sorted by frequency
+                s.heap[--s.heap_max] = m;
+                                
+                // Create a new node father of n and m
+                tree[node * 2] = unchecked((short) (tree[n * 2] + tree[m * 2]));
+                s.depth[node] = (sbyte) (System.Math.Max((byte) s.depth[n], (byte) s.depth[m]) + 1);
+                tree[n * 2 + 1] = tree[m * 2 + 1] = (short) node;
+                                
+                // and insert the new node in the heap
+                s.heap[1] = node++;
+                s.pqdownheap(tree, 1);
+            }
+            while (s.heap_len >= 2);
+                        
+            s.heap[--s.heap_max] = s.heap[1];
+                        
+            // At this point, the fields freq and dad are set. We can now
+            // generate the bit lengths.
+                        
+            gen_bitlen(s);
+                        
+            // The field len is now set, we can generate the bit codes
+            gen_codes(tree, max_code, s.bl_count);
+        }
+                
+        // Generate the codes for a given tree and bit counts (which need not be
+        // optimal).
+        // IN assertion: the array bl_count contains the bit length statistics for
+        // the given tree and the field len is set for all tree elements.
+        // OUT assertion: the field code is set for all tree elements of non
+        //     zero code length.
+        internal static void  gen_codes(short[] tree, int max_code, short[] bl_count)
+        {
+            short[] next_code = new short[InternalConstants.MAX_BITS + 1]; // next code value for each bit length
+            short code = 0; // running code value
+            int bits; // bit index
+            int n; // code index
+                        
+            // The distribution counts are first used to generate the code values
+            // without bit reversal.
+            for (bits = 1; bits <= InternalConstants.MAX_BITS; bits++)
+                unchecked {
+                    next_code[bits] = code = (short) ((code + bl_count[bits - 1]) << 1);
+                }
+                        
+            // Check that the bit counts in bl_count are consistent. The last code
+            // must be all ones.
+            //Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
+            //        "inconsistent bit counts");
+            //Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
+                        
+            for (n = 0; n <= max_code; n++)
+            {
+                int len = tree[n * 2 + 1];
+                if (len == 0)
+                    continue;
+                // Now reverse the bits
+                tree[n * 2] =  unchecked((short) (bi_reverse(next_code[len]++, len)));
+            }
+        }
+                
+        // Reverse the first len bits of a code, using straightforward code (a faster
+        // method would use a table)
+        // IN assertion: 1 <= len <= 15
+        internal static int bi_reverse(int code, int len)
+        {
+            int res = 0;
+            do 
+            {
+                res |= code & 1;
+                code >>= 1; //SharedUtils.URShift(code, 1);
+                res <<= 1;
+            }
+            while (--len > 0);
+            return res >> 1;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Deflate/Zlib.cs b/MonoGame.Framework/Utilities/Deflate/Zlib.cs
new file mode 100644
index 00000000000..4132f5ed6bb
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Deflate/Zlib.cs
@@ -0,0 +1,546 @@
+// Zlib.cs
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2009-2011 Dino Chiesa and Microsoft Corporation.
+// All rights reserved.
+//
+// This code module is part of DotNetZip, a zipfile class library.
+//
+// ------------------------------------------------------------------
+//
+// This code is licensed under the Microsoft Public License.
+// See the file License.txt for the license details.
+// More info on: http://dotnetzip.codeplex.com
+//
+// ------------------------------------------------------------------
+//
+// Last Saved: <2011-August-03 19:52:28>
+//
+// ------------------------------------------------------------------
+//
+// This module defines classes for ZLIB compression and
+// decompression. This code is derived from the jzlib implementation of
+// zlib, but significantly modified.  The object model is not the same,
+// and many of the behaviors are new or different.  Nonetheless, in
+// keeping with the license for jzlib, the copyright to that code is
+// included below.
+//
+// ------------------------------------------------------------------
+//
+// The following notice applies to jzlib:
+//
+// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in
+// the documentation and/or other materials provided with the distribution.
+//
+// 3. The names of the authors may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// -----------------------------------------------------------------------
+//
+// jzlib is based on zlib-1.1.3.
+//
+// The following notice applies to zlib:
+//
+// -----------------------------------------------------------------------
+//
+// Copyright (C) 1995-2004 Jean-loup Gailly and Mark Adler
+//
+//   The ZLIB software is provided 'as-is', without any express or implied
+//   warranty.  In no event will the authors be held liable for any damages
+//   arising from the use of this software.
+//
+//   Permission is granted to anyone to use this software for any purpose,
+//   including commercial applications, and to alter it and redistribute it
+//   freely, subject to the following restrictions:
+//
+//   1. The origin of this software must not be misrepresented; you must not
+//      claim that you wrote the original software. If you use this software
+//      in a product, an acknowledgment in the product documentation would be
+//      appreciated but is not required.
+//   2. Altered source versions must be plainly marked as such, and must not be
+//      misrepresented as being the original software.
+//   3. This notice may not be removed or altered from any source distribution.
+//
+//   Jean-loup Gailly jloup@gzip.org
+//   Mark Adler madler@alumni.caltech.edu
+//
+// -----------------------------------------------------------------------
+
+
+
+using System;
+using Interop=System.Runtime.InteropServices;
+
+namespace MonoGame.Utilities.Deflate
+{
+
+    /// <summary>
+    /// Describes how to flush the current deflate operation.
+    /// </summary>
+    /// <remarks>
+    /// The different FlushType values are useful when using a Deflate in a streaming application.
+    /// </remarks>
+    public enum FlushType
+    {
+        /// <summary>No flush at all.</summary>
+        None = 0,
+
+        /// <summary>Closes the current block, but doesn't flush it to
+        /// the output. Used internally only in hypothetical
+        /// scenarios.  This was supposed to be removed by Zlib, but it is
+        /// still in use in some edge cases.
+        /// </summary>
+        Partial,
+
+        /// <summary>
+        /// Use this during compression to specify that all pending output should be
+        /// flushed to the output buffer and the output should be aligned on a byte
+        /// boundary.  You might use this in a streaming communication scenario, so that
+        /// the decompressor can get all input data available so far.  When using this
+        /// with a ZlibCodec, <c>AvailableBytesIn</c> will be zero after the call if
+        /// enough output space has been provided before the call.  Flushing will
+        /// degrade compression and so it should be used only when necessary.
+        /// </summary>
+        Sync,
+
+        /// <summary>
+        /// Use this during compression to specify that all output should be flushed, as
+        /// with <c>FlushType.Sync</c>, but also, the compression state should be reset
+        /// so that decompression can restart from this point if previous compressed
+        /// data has been damaged or if random access is desired.  Using
+        /// <c>FlushType.Full</c> too often can significantly degrade the compression.
+        /// </summary>
+        Full,
+
+        /// <summary>Signals the end of the compression/decompression stream.</summary>
+        Finish,
+    }
+
+
+    /// <summary>
+    /// The compression level to be used when using a DeflateStream or ZlibStream with CompressionMode.Compress.
+    /// </summary>
+    public enum CompressionLevel
+    {
+        /// <summary>
+        /// None means that the data will be simply stored, with no change at all.
+        /// If you are producing ZIPs for use on Mac OSX, be aware that archives produced with CompressionLevel.None
+        /// cannot be opened with the default zip reader. Use a different CompressionLevel.
+        /// </summary>
+        None= 0,
+        /// <summary>
+        /// Same as None.
+        /// </summary>
+        Level0 = 0,
+
+        /// <summary>
+        /// The fastest but least effective compression.
+        /// </summary>
+        BestSpeed = 1,
+
+        /// <summary>
+        /// A synonym for BestSpeed.
+        /// </summary>
+        Level1 = 1,
+
+        /// <summary>
+        /// A little slower, but better, than level 1.
+        /// </summary>
+        Level2 = 2,
+
+        /// <summary>
+        /// A little slower, but better, than level 2.
+        /// </summary>
+        Level3 = 3,
+
+        /// <summary>
+        /// A little slower, but better, than level 3.
+        /// </summary>
+        Level4 = 4,
+
+        /// <summary>
+        /// A little slower than level 4, but with better compression.
+        /// </summary>
+        Level5 = 5,
+
+        /// <summary>
+        /// The default compression level, with a good balance of speed and compression efficiency.
+        /// </summary>
+        Default = 6,
+        /// <summary>
+        /// A synonym for Default.
+        /// </summary>
+        Level6 = 6,
+
+        /// <summary>
+        /// Pretty good compression!
+        /// </summary>
+        Level7 = 7,
+
+        /// <summary>
+        ///  Better compression than Level7!
+        /// </summary>
+        Level8 = 8,
+
+        /// <summary>
+        /// The "best" compression, where best means greatest reduction in size of the input data stream.
+        /// This is also the slowest compression.
+        /// </summary>
+        BestCompression = 9,
+
+        /// <summary>
+        /// A synonym for BestCompression.
+        /// </summary>
+        Level9 = 9,
+    }
+
+    /// <summary>
+    /// Describes options for how the compression algorithm is executed.  Different strategies
+    /// work better on different sorts of data.  The strategy parameter can affect the compression
+    /// ratio and the speed of compression but not the correctness of the compresssion.
+    /// </summary>
+    public enum CompressionStrategy
+    {
+        /// <summary>
+        /// The default strategy is probably the best for normal data.
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        /// The <c>Filtered</c> strategy is intended to be used most effectively with data produced by a
+        /// filter or predictor.  By this definition, filtered data consists mostly of small
+        /// values with a somewhat random distribution.  In this case, the compression algorithm
+        /// is tuned to compress them better.  The effect of <c>Filtered</c> is to force more Huffman
+        /// coding and less string matching; it is a half-step between <c>Default</c> and <c>HuffmanOnly</c>.
+        /// </summary>
+        Filtered = 1,
+
+        /// <summary>
+        /// Using <c>HuffmanOnly</c> will force the compressor to do Huffman encoding only, with no
+        /// string matching.
+        /// </summary>
+        HuffmanOnly = 2,
+    }
+
+
+    /// <summary>
+    /// An enum to specify the direction of transcoding - whether to compress or decompress.
+    /// </summary>
+    public enum CompressionMode
+    {
+        /// <summary>
+        /// Used to specify that the stream should compress the data.
+        /// </summary>
+        Compress= 0,
+        /// <summary>
+        /// Used to specify that the stream should decompress the data.
+        /// </summary>
+        Decompress = 1,
+    }
+
+
+    /// <summary>
+    /// A general purpose exception class for exceptions in the Zlib library.
+    /// </summary>
+    [Interop.GuidAttribute("ebc25cf6-9120-4283-b972-0e5520d0000E")]
+    public class ZlibException : System.Exception
+    {
+        /// <summary>
+        /// The ZlibException class captures exception information generated
+        /// by the Zlib library.
+        /// </summary>
+        public ZlibException()
+            : base()
+        {
+        }
+
+        /// <summary>
+        /// This ctor collects a message attached to the exception.
+        /// </summary>
+        /// <param name="s">the message for the exception.</param>
+        public ZlibException(System.String s)
+            : base(s)
+        {
+        }
+    }
+
+
+    internal class SharedUtils
+    {
+        /// <summary>
+        /// Performs an unsigned bitwise right shift with the specified number
+        /// </summary>
+        /// <param name="number">Number to operate on</param>
+        /// <param name="bits">Ammount of bits to shift</param>
+        /// <returns>The resulting number from the shift operation</returns>
+        public static int URShift(int number, int bits)
+        {
+            return (int)((uint)number >> bits);
+        }
+
+#if NOT
+        /// <summary>
+        /// Performs an unsigned bitwise right shift with the specified number
+        /// </summary>
+        /// <param name="number">Number to operate on</param>
+        /// <param name="bits">Ammount of bits to shift</param>
+        /// <returns>The resulting number from the shift operation</returns>
+        public static long URShift(long number, int bits)
+        {
+            return (long) ((UInt64)number >> bits);
+        }
+#endif
+
+        /// <summary>
+        ///   Reads a number of characters from the current source TextReader and writes
+        ///   the data to the target array at the specified index.
+        /// </summary>
+        ///
+        /// <param name="sourceTextReader">The source TextReader to read from</param>
+        /// <param name="target">Contains the array of characteres read from the source TextReader.</param>
+        /// <param name="start">The starting index of the target array.</param>
+        /// <param name="count">The maximum number of characters to read from the source TextReader.</param>
+        ///
+        /// <returns>
+        ///   The number of characters read. The number will be less than or equal to
+        ///   count depending on the data available in the source TextReader. Returns -1
+        ///   if the end of the stream is reached.
+        /// </returns>
+        public static System.Int32 ReadInput(System.IO.TextReader sourceTextReader, byte[] target, int start, int count)
+        {
+            // Returns 0 bytes if not enough space in target
+            if (target.Length == 0) return 0;
+
+            char[] charArray = new char[target.Length];
+            int bytesRead = sourceTextReader.Read(charArray, start, count);
+
+            // Returns -1 if EOF
+            if (bytesRead == 0) return -1;
+
+            for (int index = start; index < start + bytesRead; index++)
+                target[index] = (byte)charArray[index];
+
+            return bytesRead;
+        }
+
+
+        internal static byte[] ToByteArray(System.String sourceString)
+        {
+            return System.Text.UTF8Encoding.UTF8.GetBytes(sourceString);
+        }
+
+
+        internal static char[] ToCharArray(byte[] byteArray)
+        {
+            return System.Text.UTF8Encoding.UTF8.GetChars(byteArray);
+        }
+    }
+
+    internal static class InternalConstants
+    {
+        internal static readonly int MAX_BITS     = 15;
+        internal static readonly int BL_CODES     = 19;
+        internal static readonly int D_CODES      = 30;
+        internal static readonly int LITERALS     = 256;
+        internal static readonly int LENGTH_CODES = 29;
+        internal static readonly int L_CODES      = (LITERALS + 1 + LENGTH_CODES);
+
+        // Bit length codes must not exceed MAX_BL_BITS bits
+        internal static readonly int MAX_BL_BITS  = 7;
+
+        // repeat previous bit length 3-6 times (2 bits of repeat count)
+        internal static readonly int REP_3_6      = 16;
+
+        // repeat a zero length 3-10 times  (3 bits of repeat count)
+        internal static readonly int REPZ_3_10    = 17;
+
+        // repeat a zero length 11-138 times  (7 bits of repeat count)
+        internal static readonly int REPZ_11_138  = 18;
+
+    }
+
+    internal sealed class StaticTree
+    {
+        internal static readonly short[] lengthAndLiteralsTreeCodes = new short[] {
+            12, 8, 140, 8, 76, 8, 204, 8, 44, 8, 172, 8, 108, 8, 236, 8,
+            28, 8, 156, 8, 92, 8, 220, 8, 60, 8, 188, 8, 124, 8, 252, 8,
+             2, 8, 130, 8, 66, 8, 194, 8, 34, 8, 162, 8, 98, 8, 226, 8,
+            18, 8, 146, 8, 82, 8, 210, 8, 50, 8, 178, 8, 114, 8, 242, 8,
+            10, 8, 138, 8, 74, 8, 202, 8, 42, 8, 170, 8, 106, 8, 234, 8,
+            26, 8, 154, 8, 90, 8, 218, 8, 58, 8, 186, 8, 122, 8, 250, 8,
+             6, 8, 134, 8, 70, 8, 198, 8, 38, 8, 166, 8, 102, 8, 230, 8,
+            22, 8, 150, 8, 86, 8, 214, 8, 54, 8, 182, 8, 118, 8, 246, 8,
+            14, 8, 142, 8, 78, 8, 206, 8, 46, 8, 174, 8, 110, 8, 238, 8,
+            30, 8, 158, 8, 94, 8, 222, 8, 62, 8, 190, 8, 126, 8, 254, 8,
+             1, 8, 129, 8, 65, 8, 193, 8, 33, 8, 161, 8, 97, 8, 225, 8,
+            17, 8, 145, 8, 81, 8, 209, 8, 49, 8, 177, 8, 113, 8, 241, 8,
+             9, 8, 137, 8, 73, 8, 201, 8, 41, 8, 169, 8, 105, 8, 233, 8,
+            25, 8, 153, 8, 89, 8, 217, 8, 57, 8, 185, 8, 121, 8, 249, 8,
+             5, 8, 133, 8, 69, 8, 197, 8, 37, 8, 165, 8, 101, 8, 229, 8,
+            21, 8, 149, 8, 85, 8, 213, 8, 53, 8, 181, 8, 117, 8, 245, 8,
+            13, 8, 141, 8, 77, 8, 205, 8, 45, 8, 173, 8, 109, 8, 237, 8,
+            29, 8, 157, 8, 93, 8, 221, 8, 61, 8, 189, 8, 125, 8, 253, 8,
+            19, 9, 275, 9, 147, 9, 403, 9, 83, 9, 339, 9, 211, 9, 467, 9,
+            51, 9, 307, 9, 179, 9, 435, 9, 115, 9, 371, 9, 243, 9, 499, 9,
+            11, 9, 267, 9, 139, 9, 395, 9, 75, 9, 331, 9, 203, 9, 459, 9,
+            43, 9, 299, 9, 171, 9, 427, 9, 107, 9, 363, 9, 235, 9, 491, 9,
+            27, 9, 283, 9, 155, 9, 411, 9, 91, 9, 347, 9, 219, 9, 475, 9,
+            59, 9, 315, 9, 187, 9, 443, 9, 123, 9, 379, 9, 251, 9, 507, 9,
+             7, 9, 263, 9, 135, 9, 391, 9, 71, 9, 327, 9, 199, 9, 455, 9,
+            39, 9, 295, 9, 167, 9, 423, 9, 103, 9, 359, 9, 231, 9, 487, 9,
+            23, 9, 279, 9, 151, 9, 407, 9, 87, 9, 343, 9, 215, 9, 471, 9,
+            55, 9, 311, 9, 183, 9, 439, 9, 119, 9, 375, 9, 247, 9, 503, 9,
+            15, 9, 271, 9, 143, 9, 399, 9, 79, 9, 335, 9, 207, 9, 463, 9,
+            47, 9, 303, 9, 175, 9, 431, 9, 111, 9, 367, 9, 239, 9, 495, 9,
+            31, 9, 287, 9, 159, 9, 415, 9, 95, 9, 351, 9, 223, 9, 479, 9,
+            63, 9, 319, 9, 191, 9, 447, 9, 127, 9, 383, 9, 255, 9, 511, 9,
+             0, 7, 64, 7, 32, 7, 96, 7, 16, 7, 80, 7, 48, 7, 112, 7,
+             8, 7, 72, 7, 40, 7, 104, 7, 24, 7, 88, 7, 56, 7, 120, 7,
+             4, 7, 68, 7, 36, 7, 100, 7, 20, 7, 84, 7, 52, 7, 116, 7,
+             3, 8, 131, 8, 67, 8, 195, 8, 35, 8, 163, 8, 99, 8, 227, 8
+        };
+
+        internal static readonly short[] distTreeCodes = new short[] {
+            0, 5, 16, 5, 8, 5, 24, 5, 4, 5, 20, 5, 12, 5, 28, 5,
+            2, 5, 18, 5, 10, 5, 26, 5, 6, 5, 22, 5, 14, 5, 30, 5,
+            1, 5, 17, 5, 9, 5, 25, 5, 5, 5, 21, 5, 13, 5, 29, 5,
+            3, 5, 19, 5, 11, 5, 27, 5, 7, 5, 23, 5 };
+
+        internal static readonly StaticTree Literals;
+        internal static readonly StaticTree Distances;
+        internal static readonly StaticTree BitLengths;
+
+        internal short[] treeCodes; // static tree or null
+        internal int[] extraBits;   // extra bits for each code or null
+        internal int extraBase;     // base index for extra_bits
+        internal int elems;         // max number of elements in the tree
+        internal int maxLength;     // max bit length for the codes
+
+        private StaticTree(short[] treeCodes, int[] extraBits, int extraBase, int elems, int maxLength)
+        {
+            this.treeCodes = treeCodes;
+            this.extraBits = extraBits;
+            this.extraBase = extraBase;
+            this.elems = elems;
+            this.maxLength = maxLength;
+        }
+        static StaticTree()
+        {
+            Literals = new StaticTree(lengthAndLiteralsTreeCodes, Tree.ExtraLengthBits, InternalConstants.LITERALS + 1, InternalConstants.L_CODES, InternalConstants.MAX_BITS);
+            Distances = new StaticTree(distTreeCodes, Tree.ExtraDistanceBits, 0, InternalConstants.D_CODES, InternalConstants.MAX_BITS);
+            BitLengths = new StaticTree(null, Tree.extra_blbits, 0, InternalConstants.BL_CODES, InternalConstants.MAX_BL_BITS);
+        }
+    }
+
+
+
+    /// <summary>
+    /// Computes an Adler-32 checksum.
+    /// </summary>
+    /// <remarks>
+    /// The Adler checksum is similar to a CRC checksum, but faster to compute, though less
+    /// reliable.  It is used in producing RFC1950 compressed streams.  The Adler checksum
+    /// is a required part of the "ZLIB" standard.  Applications will almost never need to
+    /// use this class directly.
+    /// </remarks>
+    ///
+    /// <exclude/>
+    public sealed class Adler
+    {
+        // largest prime smaller than 65536
+        private static readonly uint BASE = 65521;
+        // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
+        private static readonly int NMAX = 5552;
+
+
+#pragma warning disable 3001
+#pragma warning disable 3002
+
+        /// <summary>
+        ///   Calculates the Adler32 checksum.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     This is used within ZLIB.  You probably don't need to use this directly.
+        ///   </para>
+        /// </remarks>
+        /// <example>
+        ///    To compute an Adler32 checksum on a byte array:
+        ///  <code>
+        ///    var adler = Adler.Adler32(0, null, 0, 0);
+        ///    adler = Adler.Adler32(adler, buffer, index, length);
+        ///  </code>
+        /// </example>
+        public static uint Adler32(uint adler, byte[] buf, int index, int len)
+        {
+            if (buf == null)
+                return 1;
+
+            uint s1 = (uint) (adler & 0xffff);
+            uint s2 = (uint) ((adler >> 16) & 0xffff);
+
+            while (len > 0)
+            {
+                int k = len < NMAX ? len : NMAX;
+                len -= k;
+                while (k >= 16)
+                {
+                    //s1 += (buf[index++] & 0xff); s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    k -= 16;
+                }
+                if (k != 0)
+                {
+                    do
+                    {
+                        s1 += buf[index++];
+                        s2 += s1;
+                    }
+                    while (--k != 0);
+                }
+                s1 %= BASE;
+                s2 %= BASE;
+            }
+            return (uint)((s2 << 16) | s1);
+        }
+#pragma warning restore 3001
+#pragma warning restore 3002
+
+    }
+
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Deflate/ZlibBaseStream.cs b/MonoGame.Framework/Utilities/Deflate/ZlibBaseStream.cs
new file mode 100644
index 00000000000..c01d8430b72
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Deflate/ZlibBaseStream.cs
@@ -0,0 +1,627 @@
+// ZlibBaseStream.cs
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
+// All rights reserved.
+//
+// This code module is part of DotNetZip, a zipfile class library.
+//
+// ------------------------------------------------------------------
+//
+// This code is licensed under the Microsoft Public License.
+// See the file License.txt for the license details.
+// More info on: http://dotnetzip.codeplex.com
+//
+// ------------------------------------------------------------------
+//
+// last saved (in emacs):
+// Time-stamp: <2011-August-06 21:22:38>
+//
+// ------------------------------------------------------------------
+//
+// This module defines the ZlibBaseStream class, which is an intnernal
+// base class for DeflateStream, ZlibStream and GZipStream.
+//
+// ------------------------------------------------------------------
+
+using System;
+using System.IO;
+
+namespace MonoGame.Utilities.Deflate
+{
+
+    internal enum ZlibStreamFlavor { ZLIB = 1950, DEFLATE = 1951, GZIP = 1952 }
+
+    internal class ZlibBaseStream : System.IO.Stream
+    {
+        protected internal ZlibCodec _z = null; // deferred init... new ZlibCodec();
+
+        protected internal StreamMode _streamMode = StreamMode.Undefined;
+        protected internal FlushType _flushMode;
+        protected internal ZlibStreamFlavor _flavor;
+        protected internal CompressionMode _compressionMode;
+        protected internal CompressionLevel _level;
+        protected internal bool _leaveOpen;
+        protected internal byte[] _workingBuffer;
+        protected internal int _bufferSize = ZlibConstants.WorkingBufferSizeDefault;
+        protected internal byte[] _buf1 = new byte[1];
+
+        protected internal System.IO.Stream _stream;
+        protected internal CompressionStrategy Strategy = CompressionStrategy.Default;
+
+        // workitem 7159
+        CRC32 crc;
+        protected internal string _GzipFileName;
+        protected internal string _GzipComment;
+        protected internal DateTime _GzipMtime;
+        protected internal int _gzipHeaderByteCount;
+
+        internal int Crc32 { get { if (crc == null) return 0; return crc.Crc32Result; } }
+
+        public ZlibBaseStream(System.IO.Stream stream,
+                              CompressionMode compressionMode,
+                              CompressionLevel level,
+                              ZlibStreamFlavor flavor,
+                              bool leaveOpen)
+            : base()
+        {
+            this._flushMode = FlushType.None;
+            //this._workingBuffer = new byte[WORKING_BUFFER_SIZE_DEFAULT];
+            this._stream = stream;
+            this._leaveOpen = leaveOpen;
+            this._compressionMode = compressionMode;
+            this._flavor = flavor;
+            this._level = level;
+            // workitem 7159
+            if (flavor == ZlibStreamFlavor.GZIP)
+            {
+                this.crc = new CRC32();
+            }
+        }
+
+
+        protected internal bool _wantCompress
+        {
+            get
+            {
+                return (this._compressionMode == CompressionMode.Compress);
+            }
+        }
+
+        private ZlibCodec z
+        {
+            get
+            {
+                if (_z == null)
+                {
+                    bool wantRfc1950Header = (this._flavor == ZlibStreamFlavor.ZLIB);
+                    _z = new ZlibCodec();
+                    if (this._compressionMode == CompressionMode.Decompress)
+                    {
+                        _z.InitializeInflate(wantRfc1950Header);
+                    }
+                    else
+                    {
+                        _z.Strategy = Strategy;
+                        _z.InitializeDeflate(this._level, wantRfc1950Header);
+                    }
+                }
+                return _z;
+            }
+        }
+
+
+
+        private byte[] workingBuffer
+        {
+            get
+            {
+                if (_workingBuffer == null)
+                    _workingBuffer = new byte[_bufferSize];
+                return _workingBuffer;
+            }
+        }
+
+
+
+        public override void Write(System.Byte[] buffer, int offset, int count)
+        {
+            // workitem 7159
+            // calculate the CRC on the unccompressed data  (before writing)
+            if (crc != null)
+                crc.SlurpBlock(buffer, offset, count);
+
+            if (_streamMode == StreamMode.Undefined)
+                _streamMode = StreamMode.Writer;
+            else if (_streamMode != StreamMode.Writer)
+                throw new ZlibException("Cannot Write after Reading.");
+
+            if (count == 0)
+                return;
+
+            // first reference of z property will initialize the private var _z
+            z.InputBuffer = buffer;
+            _z.NextIn = offset;
+            _z.AvailableBytesIn = count;
+            bool done = false;
+            do
+            {
+                _z.OutputBuffer = workingBuffer;
+                _z.NextOut = 0;
+                _z.AvailableBytesOut = _workingBuffer.Length;
+                int rc = (_wantCompress)
+                    ? _z.Deflate(_flushMode)
+                    : _z.Inflate(_flushMode);
+                if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
+                    throw new ZlibException((_wantCompress ? "de" : "in") + "flating: " + _z.Message);
+
+                //if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
+                _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut);
+
+                done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;
+
+                // If GZIP and de-compress, we're done when 8 bytes remain.
+                if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
+                    done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);
+
+            }
+            while (!done);
+        }
+
+
+
+        private void finish()
+        {
+            if (_z == null) return;
+
+            if (_streamMode == StreamMode.Writer)
+            {
+                bool done = false;
+                do
+                {
+                    _z.OutputBuffer = workingBuffer;
+                    _z.NextOut = 0;
+                    _z.AvailableBytesOut = _workingBuffer.Length;
+                    int rc = (_wantCompress)
+                        ? _z.Deflate(FlushType.Finish)
+                        : _z.Inflate(FlushType.Finish);
+
+                    if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
+                    {
+                        string verb = (_wantCompress ? "de" : "in") + "flating";
+                        if (_z.Message == null)
+                            throw new ZlibException(String.Format("{0}: (rc = {1})", verb, rc));
+                        else
+                            throw new ZlibException(verb + ": " + _z.Message);
+                    }
+
+                    if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
+                    {
+                        _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut);
+                    }
+
+                    done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;
+                    // If GZIP and de-compress, we're done when 8 bytes remain.
+                    if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
+                        done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);
+
+                }
+                while (!done);
+
+                Flush();
+
+                // workitem 7159
+                if (_flavor == ZlibStreamFlavor.GZIP)
+                {
+                    if (_wantCompress)
+                    {
+                        // Emit the GZIP trailer: CRC32 and  size mod 2^32
+                        int c1 = crc.Crc32Result;
+                        _stream.Write(BitConverter.GetBytes(c1), 0, 4);
+                        int c2 = (Int32)(crc.TotalBytesRead & 0x00000000FFFFFFFF);
+                        _stream.Write(BitConverter.GetBytes(c2), 0, 4);
+                    }
+                    else
+                    {
+                        throw new ZlibException("Writing with decompression is not supported.");
+                    }
+                }
+            }
+            // workitem 7159
+            else if (_streamMode == StreamMode.Reader)
+            {
+                if (_flavor == ZlibStreamFlavor.GZIP)
+                {
+                    if (!_wantCompress)
+                    {
+                        // workitem 8501: handle edge case (decompress empty stream)
+                        if (_z.TotalBytesOut == 0L)
+                            return;
+
+                        // Read and potentially verify the GZIP trailer:
+                        // CRC32 and size mod 2^32
+                        byte[] trailer = new byte[8];
+
+                        // workitems 8679 & 12554
+                        if (_z.AvailableBytesIn < 8)
+                        {
+                            // Make sure we have read to the end of the stream
+                            Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, _z.AvailableBytesIn);
+                            int bytesNeeded = 8 - _z.AvailableBytesIn;
+                            int bytesRead = _stream.Read(trailer,
+                                                         _z.AvailableBytesIn,
+                                                         bytesNeeded);
+                            if (bytesNeeded != bytesRead)
+                            {
+                                throw new ZlibException(String.Format("Missing or incomplete GZIP trailer. Expected 8 bytes, got {0}.",
+                                                                      _z.AvailableBytesIn + bytesRead));
+                            }
+                        }
+                        else
+                        {
+                            Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, trailer.Length);
+                        }
+
+                        Int32 crc32_expected = BitConverter.ToInt32(trailer, 0);
+                        Int32 crc32_actual = crc.Crc32Result;
+                        Int32 isize_expected = BitConverter.ToInt32(trailer, 4);
+                        Int32 isize_actual = (Int32)(_z.TotalBytesOut & 0x00000000FFFFFFFF);
+
+                        if (crc32_actual != crc32_expected)
+                            throw new ZlibException(String.Format("Bad CRC32 in GZIP trailer. (actual({0:X8})!=expected({1:X8}))", crc32_actual, crc32_expected));
+
+                        if (isize_actual != isize_expected)
+                            throw new ZlibException(String.Format("Bad size in GZIP trailer. (actual({0})!=expected({1}))", isize_actual, isize_expected));
+
+                    }
+                    else
+                    {
+                        throw new ZlibException("Reading with compression is not supported.");
+                    }
+                }
+            }
+        }
+
+
+        private void end()
+        {
+            if (z == null)
+                return;
+            if (_wantCompress)
+            {
+                _z.EndDeflate();
+            }
+            else
+            {
+                _z.EndInflate();
+            }
+            _z = null;
+        }
+
+
+        public override void Close()
+        {
+            if (_stream == null) return;
+            try
+            {
+                finish();
+            }
+            finally
+            {
+                end();
+                if (!_leaveOpen) _stream.Close();
+                _stream = null;
+            }
+        }
+
+        public override void Flush()
+        {
+            _stream.Flush();
+        }
+
+        public override System.Int64 Seek(System.Int64 offset, System.IO.SeekOrigin origin)
+        {
+            throw new NotImplementedException();
+            //_outStream.Seek(offset, origin);
+        }
+        public override void SetLength(System.Int64 value)
+        {
+            _stream.SetLength(value);
+        }
+
+
+#if NOT
+        public int Read()
+        {
+            if (Read(_buf1, 0, 1) == 0)
+                return 0;
+            // calculate CRC after reading
+            if (crc!=null)
+                crc.SlurpBlock(_buf1,0,1);
+            return (_buf1[0] & 0xFF);
+        }
+#endif
+
+        private bool nomoreinput = false;
+
+
+
+        private string ReadZeroTerminatedString()
+        {
+            var list = new System.Collections.Generic.List<byte>();
+            bool done = false;
+            do
+            {
+                // workitem 7740
+                int n = _stream.Read(_buf1, 0, 1);
+                if (n != 1)
+                    throw new ZlibException("Unexpected EOF reading GZIP header.");
+                else
+                {
+                    if (_buf1[0] == 0)
+                        done = true;
+                    else
+                        list.Add(_buf1[0]);
+                }
+            } while (!done);
+            byte[] a = list.ToArray();
+            return GZipStream.iso8859dash1.GetString(a, 0, a.Length);
+        }
+
+
+        private int _ReadAndValidateGzipHeader()
+        {
+            int totalBytesRead = 0;
+            // read the header on the first read
+            byte[] header = new byte[10];
+            int n = _stream.Read(header, 0, header.Length);
+
+            // workitem 8501: handle edge case (decompress empty stream)
+            if (n == 0)
+                return 0;
+
+            if (n != 10)
+                throw new ZlibException("Not a valid GZIP stream.");
+
+            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+                throw new ZlibException("Bad GZIP header.");
+
+            Int32 timet = BitConverter.ToInt32(header, 4);
+            _GzipMtime = GZipStream._unixEpoch.AddSeconds(timet);
+            totalBytesRead += n;
+            if ((header[3] & 0x04) == 0x04)
+            {
+                // read and discard extra field
+                n = _stream.Read(header, 0, 2); // 2-byte length field
+                totalBytesRead += n;
+
+                Int16 extraLength = (Int16)(header[0] + header[1] * 256);
+                byte[] extra = new byte[extraLength];
+                n = _stream.Read(extra, 0, extra.Length);
+                if (n != extraLength)
+                    throw new ZlibException("Unexpected end-of-file reading GZIP header.");
+                totalBytesRead += n;
+            }
+            if ((header[3] & 0x08) == 0x08)
+                _GzipFileName = ReadZeroTerminatedString();
+            if ((header[3] & 0x10) == 0x010)
+                _GzipComment = ReadZeroTerminatedString();
+            if ((header[3] & 0x02) == 0x02)
+                Read(_buf1, 0, 1); // CRC16, ignore
+
+            return totalBytesRead;
+        }
+
+
+
+        public override System.Int32 Read(System.Byte[] buffer, System.Int32 offset, System.Int32 count)
+        {
+            // According to MS documentation, any implementation of the IO.Stream.Read function must:
+            // (a) throw an exception if offset & count reference an invalid part of the buffer,
+            //     or if count < 0, or if buffer is null
+            // (b) return 0 only upon EOF, or if count = 0
+            // (c) if not EOF, then return at least 1 byte, up to <count> bytes
+
+            if (_streamMode == StreamMode.Undefined)
+            {
+                if (!this._stream.CanRead) throw new ZlibException("The stream is not readable.");
+                // for the first read, set up some controls.
+                _streamMode = StreamMode.Reader;
+                // (The first reference to _z goes through the private accessor which
+                // may initialize it.)
+                z.AvailableBytesIn = 0;
+                if (_flavor == ZlibStreamFlavor.GZIP)
+                {
+                    _gzipHeaderByteCount = _ReadAndValidateGzipHeader();
+                    // workitem 8501: handle edge case (decompress empty stream)
+                    if (_gzipHeaderByteCount == 0)
+                        return 0;
+                }
+            }
+
+            if (_streamMode != StreamMode.Reader)
+                throw new ZlibException("Cannot Read after Writing.");
+
+            if (count == 0) return 0;
+            if (nomoreinput && _wantCompress) return 0;  // workitem 8557
+            if (buffer == null) throw new ArgumentNullException("buffer");
+            if (count < 0) throw new ArgumentOutOfRangeException("count");
+            if (offset < buffer.GetLowerBound(0)) throw new ArgumentOutOfRangeException("offset");
+            if ((offset + count) > buffer.GetLength(0)) throw new ArgumentOutOfRangeException("count");
+
+            int rc = 0;
+
+            // set up the output of the deflate/inflate codec:
+            _z.OutputBuffer = buffer;
+            _z.NextOut = offset;
+            _z.AvailableBytesOut = count;
+
+            // This is necessary in case _workingBuffer has been resized. (new byte[])
+            // (The first reference to _workingBuffer goes through the private accessor which
+            // may initialize it.)
+            _z.InputBuffer = workingBuffer;
+
+            do
+            {
+                // need data in _workingBuffer in order to deflate/inflate.  Here, we check if we have any.
+                if ((_z.AvailableBytesIn == 0) && (!nomoreinput))
+                {
+                    // No data available, so try to Read data from the captive stream.
+                    _z.NextIn = 0;
+                    _z.AvailableBytesIn = _stream.Read(_workingBuffer, 0, _workingBuffer.Length);
+                    if (_z.AvailableBytesIn == 0)
+                        nomoreinput = true;
+
+                }
+                // we have data in InputBuffer; now compress or decompress as appropriate
+                rc = (_wantCompress)
+                    ? _z.Deflate(_flushMode)
+                    : _z.Inflate(_flushMode);
+
+                if (nomoreinput && (rc == ZlibConstants.Z_BUF_ERROR))
+                    return 0;
+
+                if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
+                    throw new ZlibException(String.Format("{0}flating:  rc={1}  msg={2}", (_wantCompress ? "de" : "in"), rc, _z.Message));
+
+                if ((nomoreinput || rc == ZlibConstants.Z_STREAM_END) && (_z.AvailableBytesOut == count))
+                    break; // nothing more to read
+            }
+            //while (_z.AvailableBytesOut == count && rc == ZlibConstants.Z_OK);
+            while (_z.AvailableBytesOut > 0 && !nomoreinput && rc == ZlibConstants.Z_OK);
+
+
+            // workitem 8557
+            // is there more room in output?
+            if (_z.AvailableBytesOut > 0)
+            {
+                if (rc == ZlibConstants.Z_OK && _z.AvailableBytesIn == 0)
+                {
+                    // deferred
+                }
+
+                // are we completely done reading?
+                if (nomoreinput)
+                {
+                    // and in compression?
+                    if (_wantCompress)
+                    {
+                        // no more input data available; therefore we flush to
+                        // try to complete the read
+                        rc = _z.Deflate(FlushType.Finish);
+
+                        if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
+                            throw new ZlibException(String.Format("Deflating:  rc={0}  msg={1}", rc, _z.Message));
+                    }
+                }
+            }
+
+
+            rc = (count - _z.AvailableBytesOut);
+
+            // calculate CRC after reading
+            if (crc != null)
+                crc.SlurpBlock(buffer, offset, rc);
+
+            return rc;
+        }
+
+
+
+        public override System.Boolean CanRead
+        {
+            get { return this._stream.CanRead; }
+        }
+
+        public override System.Boolean CanSeek
+        {
+            get { return this._stream.CanSeek; }
+        }
+
+        public override System.Boolean CanWrite
+        {
+            get { return this._stream.CanWrite; }
+        }
+
+        public override System.Int64 Length
+        {
+            get { return _stream.Length; }
+        }
+
+        public override long Position
+        {
+            get { throw new NotImplementedException(); }
+            set { throw new NotImplementedException(); }
+        }
+
+        internal enum StreamMode
+        {
+            Writer,
+            Reader,
+            Undefined,
+        }
+
+
+        public static void CompressString(String s, Stream compressor)
+        {
+            byte[] uncompressed = System.Text.Encoding.UTF8.GetBytes(s);
+            using (compressor)
+            {
+                compressor.Write(uncompressed, 0, uncompressed.Length);
+            }
+        }
+
+        public static void CompressBuffer(byte[] b, Stream compressor)
+        {
+            // workitem 8460
+            using (compressor)
+            {
+                compressor.Write(b, 0, b.Length);
+            }
+        }
+
+        public static String UncompressString(byte[] compressed, Stream decompressor)
+        {
+            // workitem 8460
+            byte[] working = new byte[1024];
+            var encoding = System.Text.Encoding.UTF8;
+            using (var output = new MemoryStream())
+            {
+                using (decompressor)
+                {
+                    int n;
+                    while ((n = decompressor.Read(working, 0, working.Length)) != 0)
+                    {
+                        output.Write(working, 0, n);
+                    }
+                }
+
+                // reset to allow read from start
+                output.Seek(0, SeekOrigin.Begin);
+                var sr = new StreamReader(output, encoding);
+                return sr.ReadToEnd();
+            }
+        }
+
+        public static byte[] UncompressBuffer(byte[] compressed, Stream decompressor)
+        {
+            // workitem 8460
+            byte[] working = new byte[1024];
+            using (var output = new MemoryStream())
+            {
+                using (decompressor)
+                {
+                    int n;
+                    while ((n = decompressor.Read(working, 0, working.Length)) != 0)
+                    {
+                        output.Write(working, 0, n);
+                    }
+                }
+                return output.ToArray();
+            }
+        }
+
+    }
+
+
+}
diff --git a/MonoGame.Framework/Utilities/Deflate/ZlibCodec.cs b/MonoGame.Framework/Utilities/Deflate/ZlibCodec.cs
new file mode 100644
index 00000000000..d3b7720cc87
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Deflate/ZlibCodec.cs
@@ -0,0 +1,712 @@
+// ZlibCodec.cs
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.  
+// All rights reserved.
+//
+// This code module is part of DotNetZip, a zipfile class library.
+//
+// ------------------------------------------------------------------
+//
+// This code is licensed under the Microsoft Public License. 
+// See the file License.txt for the license details.
+// More info on: http://dotnetzip.codeplex.com
+//
+// ------------------------------------------------------------------
+//
+// last saved (in emacs): 
+// Time-stamp: <2009-November-03 15:40:51>
+//
+// ------------------------------------------------------------------
+//
+// This module defines a Codec for ZLIB compression and
+// decompression. This code extends code that was based the jzlib
+// implementation of zlib, but this code is completely novel.  The codec
+// class is new, and encapsulates some behaviors that are new, and some
+// that were present in other classes in the jzlib code base.  In
+// keeping with the license for jzlib, the copyright to the jzlib code
+// is included below.
+//
+// ------------------------------------------------------------------
+// 
+// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright 
+// notice, this list of conditions and the following disclaimer in 
+// the documentation and/or other materials provided with the distribution.
+// 
+// 3. The names of the authors may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+// -----------------------------------------------------------------------
+//
+// This program is based on zlib-1.1.3; credit to authors
+// Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+// and contributors of zlib.
+//
+// -----------------------------------------------------------------------
+
+
+using System;
+
+namespace MonoGame.Utilities.Deflate
+{
+    /// <summary>
+    /// Encoder and Decoder for ZLIB and DEFLATE (IETF RFC1950 and RFC1951).
+    /// </summary>
+    ///
+    /// <remarks>
+    /// This class compresses and decompresses data according to the Deflate algorithm
+    /// and optionally, the ZLIB format, as documented in <see
+    /// href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950 - ZLIB</see> and <see
+    /// href="http://www.ietf.org/rfc/rfc1951.txt">RFC 1951 - DEFLATE</see>.
+    /// </remarks>
+
+    sealed public class ZlibCodec
+    {
+        /// <summary>
+        /// The buffer from which data is taken.
+        /// </summary>
+        public byte[] InputBuffer;
+
+        /// <summary>
+        /// An index into the InputBuffer array, indicating where to start reading. 
+        /// </summary>
+        public int NextIn;
+
+        /// <summary>
+        /// The number of bytes available in the InputBuffer, starting at NextIn. 
+        /// </summary>
+        /// <remarks>
+        /// Generally you should set this to InputBuffer.Length before the first Inflate() or Deflate() call. 
+        /// The class will update this number as calls to Inflate/Deflate are made.
+        /// </remarks>
+        public int AvailableBytesIn;
+
+        /// <summary>
+        /// Total number of bytes read so far, through all calls to Inflate()/Deflate().
+        /// </summary>
+        public long TotalBytesIn;
+
+        /// <summary>
+        /// Buffer to store output data.
+        /// </summary>
+        public byte[] OutputBuffer;
+
+        /// <summary>
+        /// An index into the OutputBuffer array, indicating where to start writing. 
+        /// </summary>
+        public int NextOut;
+
+        /// <summary>
+        /// The number of bytes available in the OutputBuffer, starting at NextOut. 
+        /// </summary>
+        /// <remarks>
+        /// Generally you should set this to OutputBuffer.Length before the first Inflate() or Deflate() call. 
+        /// The class will update this number as calls to Inflate/Deflate are made.
+        /// </remarks>
+        public int AvailableBytesOut;
+
+        /// <summary>
+        /// Total number of bytes written to the output so far, through all calls to Inflate()/Deflate().
+        /// </summary>
+        public long TotalBytesOut;
+
+        /// <summary>
+        /// used for diagnostics, when something goes wrong!
+        /// </summary>
+        public System.String Message;
+
+        internal DeflateManager dstate;
+        internal InflateManager istate;
+
+        internal uint _Adler32;
+
+        /// <summary>
+        /// The compression level to use in this codec.  Useful only in compression mode.
+        /// </summary>
+        public CompressionLevel CompressLevel = CompressionLevel.Default;
+
+        /// <summary>
+        /// The number of Window Bits to use.  
+        /// </summary>
+        /// <remarks>
+        /// This gauges the size of the sliding window, and hence the 
+        /// compression effectiveness as well as memory consumption. It's best to just leave this 
+        /// setting alone if you don't know what it is.  The maximum value is 15 bits, which implies
+        /// a 32k window.  
+        /// </remarks>
+        public int WindowBits = ZlibConstants.WindowBitsDefault;
+
+        /// <summary>
+        /// The compression strategy to use.
+        /// </summary>
+        /// <remarks>
+        /// This is only effective in compression.  The theory offered by ZLIB is that different
+        /// strategies could potentially produce significant differences in compression behavior
+        /// for different data sets.  Unfortunately I don't have any good recommendations for how
+        /// to set it differently.  When I tested changing the strategy I got minimally different
+        /// compression performance. It's best to leave this property alone if you don't have a
+        /// good feel for it.  Or, you may want to produce a test harness that runs through the
+        /// different strategy options and evaluates them on different file types. If you do that,
+        /// let me know your results.
+        /// </remarks>
+        public CompressionStrategy Strategy = CompressionStrategy.Default;
+
+
+        /// <summary>
+        /// The Adler32 checksum on the data transferred through the codec so far. You probably don't need to look at this.
+        /// </summary>
+        public int Adler32 { get { return (int)_Adler32; } }
+
+
+        /// <summary>
+        /// Create a ZlibCodec.
+        /// </summary>
+        /// <remarks>
+        /// If you use this default constructor, you will later have to explicitly call 
+        /// InitializeInflate() or InitializeDeflate() before using the ZlibCodec to compress 
+        /// or decompress. 
+        /// </remarks>
+        public ZlibCodec() { }
+
+        /// <summary>
+        /// Create a ZlibCodec that either compresses or decompresses.
+        /// </summary>
+        /// <param name="mode">
+        /// Indicates whether the codec should compress (deflate) or decompress (inflate).
+        /// </param>
+        public ZlibCodec(CompressionMode mode)
+        {
+            if (mode == CompressionMode.Compress)
+            {
+                int rc = InitializeDeflate();
+                if (rc != ZlibConstants.Z_OK) throw new ZlibException("Cannot initialize for deflate.");
+            }
+            else if (mode == CompressionMode.Decompress)
+            {
+                int rc = InitializeInflate();
+                if (rc != ZlibConstants.Z_OK) throw new ZlibException("Cannot initialize for inflate.");
+            }
+            else throw new ZlibException("Invalid ZlibStreamFlavor.");
+        }
+
+        /// <summary>
+        /// Initialize the inflation state. 
+        /// </summary>
+        /// <remarks>
+        /// It is not necessary to call this before using the ZlibCodec to inflate data; 
+        /// It is implicitly called when you call the constructor.
+        /// </remarks>
+        /// <returns>Z_OK if everything goes well.</returns>
+        public int InitializeInflate()
+        {
+            return InitializeInflate(this.WindowBits);
+        }
+
+        /// <summary>
+        /// Initialize the inflation state with an explicit flag to
+        /// govern the handling of RFC1950 header bytes.
+        /// </summary>
+        ///
+        /// <remarks>
+        /// By default, the ZLIB header defined in <see
+        /// href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950</see> is expected.  If
+        /// you want to read a zlib stream you should specify true for
+        /// expectRfc1950Header.  If you have a deflate stream, you will want to specify
+        /// false. It is only necessary to invoke this initializer explicitly if you
+        /// want to specify false.
+        /// </remarks>
+        ///
+        /// <param name="expectRfc1950Header">whether to expect an RFC1950 header byte
+        /// pair when reading the stream of data to be inflated.</param>
+        ///
+        /// <returns>Z_OK if everything goes well.</returns>
+        public int InitializeInflate(bool expectRfc1950Header)
+        {
+            return InitializeInflate(this.WindowBits, expectRfc1950Header);
+        }
+
+        /// <summary>
+        /// Initialize the ZlibCodec for inflation, with the specified number of window bits. 
+        /// </summary>
+        /// <param name="windowBits">The number of window bits to use. If you need to ask what that is, 
+        /// then you shouldn't be calling this initializer.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        public int InitializeInflate(int windowBits)
+        {
+            this.WindowBits = windowBits;            
+            return InitializeInflate(windowBits, true);
+        }
+
+        /// <summary>
+        /// Initialize the inflation state with an explicit flag to govern the handling of
+        /// RFC1950 header bytes. 
+        /// </summary>
+        ///
+        /// <remarks>
+        /// If you want to read a zlib stream you should specify true for
+        /// expectRfc1950Header. In this case, the library will expect to find a ZLIB
+        /// header, as defined in <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC
+        /// 1950</see>, in the compressed stream.  If you will be reading a DEFLATE or
+        /// GZIP stream, which does not have such a header, you will want to specify
+        /// false.
+        /// </remarks>
+        ///
+        /// <param name="expectRfc1950Header">whether to expect an RFC1950 header byte pair when reading 
+        /// the stream of data to be inflated.</param>
+        /// <param name="windowBits">The number of window bits to use. If you need to ask what that is, 
+        /// then you shouldn't be calling this initializer.</param>
+        /// <returns>Z_OK if everything goes well.</returns>
+        public int InitializeInflate(int windowBits, bool expectRfc1950Header)
+        {
+            this.WindowBits = windowBits;
+            if (dstate != null) throw new ZlibException("You may not call InitializeInflate() after calling InitializeDeflate().");
+            istate = new InflateManager(expectRfc1950Header);
+            return istate.Initialize(this, windowBits);
+        }
+
+        /// <summary>
+        /// Inflate the data in the InputBuffer, placing the result in the OutputBuffer.
+        /// </summary>
+        /// <remarks>
+        /// You must have set InputBuffer and OutputBuffer, NextIn and NextOut, and AvailableBytesIn and 
+        /// AvailableBytesOut  before calling this method.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// private void InflateBuffer()
+        /// {
+        ///     int bufferSize = 1024;
+        ///     byte[] buffer = new byte[bufferSize];
+        ///     ZlibCodec decompressor = new ZlibCodec();
+        /// 
+        ///     Console.WriteLine("\n============================================");
+        ///     Console.WriteLine("Size of Buffer to Inflate: {0} bytes.", CompressedBytes.Length);
+        ///     MemoryStream ms = new MemoryStream(DecompressedBytes);
+        /// 
+        ///     int rc = decompressor.InitializeInflate();
+        /// 
+        ///     decompressor.InputBuffer = CompressedBytes;
+        ///     decompressor.NextIn = 0;
+        ///     decompressor.AvailableBytesIn = CompressedBytes.Length;
+        /// 
+        ///     decompressor.OutputBuffer = buffer;
+        /// 
+        ///     // pass 1: inflate 
+        ///     do
+        ///     {
+        ///         decompressor.NextOut = 0;
+        ///         decompressor.AvailableBytesOut = buffer.Length;
+        ///         rc = decompressor.Inflate(FlushType.None);
+        /// 
+        ///         if (rc != ZlibConstants.Z_OK &amp;&amp; rc != ZlibConstants.Z_STREAM_END)
+        ///             throw new Exception("inflating: " + decompressor.Message);
+        /// 
+        ///         ms.Write(decompressor.OutputBuffer, 0, buffer.Length - decompressor.AvailableBytesOut);
+        ///     }
+        ///     while (decompressor.AvailableBytesIn &gt; 0 || decompressor.AvailableBytesOut == 0);
+        /// 
+        ///     // pass 2: finish and flush
+        ///     do
+        ///     {
+        ///         decompressor.NextOut = 0;
+        ///         decompressor.AvailableBytesOut = buffer.Length;
+        ///         rc = decompressor.Inflate(FlushType.Finish);
+        /// 
+        ///         if (rc != ZlibConstants.Z_STREAM_END &amp;&amp; rc != ZlibConstants.Z_OK)
+        ///             throw new Exception("inflating: " + decompressor.Message);
+        /// 
+        ///         if (buffer.Length - decompressor.AvailableBytesOut &gt; 0)
+        ///             ms.Write(buffer, 0, buffer.Length - decompressor.AvailableBytesOut);
+        ///     }
+        ///     while (decompressor.AvailableBytesIn &gt; 0 || decompressor.AvailableBytesOut == 0);
+        /// 
+        ///     decompressor.EndInflate();
+        /// }
+        ///
+        /// </code>
+        /// </example>
+        /// <param name="flush">The flush to use when inflating.</param>
+        /// <returns>Z_OK if everything goes well.</returns>
+        public int Inflate(FlushType flush)
+        {
+            if (istate == null)
+                throw new ZlibException("No Inflate State!");
+            return istate.Inflate(flush);
+        }
+
+
+        /// <summary>
+        /// Ends an inflation session. 
+        /// </summary>
+        /// <remarks>
+        /// Call this after successively calling Inflate().  This will cause all buffers to be flushed. 
+        /// After calling this you cannot call Inflate() without a intervening call to one of the
+        /// InitializeInflate() overloads.
+        /// </remarks>
+        /// <returns>Z_OK if everything goes well.</returns>
+        public int EndInflate()
+        {
+            if (istate == null)
+                throw new ZlibException("No Inflate State!");
+            int ret = istate.End();
+            istate = null;
+            return ret;
+        }
+
+        /// <summary>
+        /// I don't know what this does!
+        /// </summary>
+        /// <returns>Z_OK if everything goes well.</returns>
+        public int SyncInflate()
+        {
+            if (istate == null)
+                throw new ZlibException("No Inflate State!");
+            return istate.Sync();
+        }
+
+        /// <summary>
+        /// Initialize the ZlibCodec for deflation operation.
+        /// </summary>
+        /// <remarks>
+        /// The codec will use the MAX window bits and the default level of compression.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        ///  int bufferSize = 40000;
+        ///  byte[] CompressedBytes = new byte[bufferSize];
+        ///  byte[] DecompressedBytes = new byte[bufferSize];
+        ///  
+        ///  ZlibCodec compressor = new ZlibCodec();
+        ///  
+        ///  compressor.InitializeDeflate(CompressionLevel.Default);
+        ///  
+        ///  compressor.InputBuffer = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);
+        ///  compressor.NextIn = 0;
+        ///  compressor.AvailableBytesIn = compressor.InputBuffer.Length;
+        ///  
+        ///  compressor.OutputBuffer = CompressedBytes;
+        ///  compressor.NextOut = 0;
+        ///  compressor.AvailableBytesOut = CompressedBytes.Length;
+        ///  
+        ///  while (compressor.TotalBytesIn != TextToCompress.Length &amp;&amp; compressor.TotalBytesOut &lt; bufferSize)
+        ///  {
+        ///    compressor.Deflate(FlushType.None);
+        ///  }
+        ///  
+        ///  while (true)
+        ///  {
+        ///    int rc= compressor.Deflate(FlushType.Finish);
+        ///    if (rc == ZlibConstants.Z_STREAM_END) break;
+        ///  }
+        ///  
+        ///  compressor.EndDeflate();
+        ///   
+        /// </code>
+        /// </example>
+        /// <returns>Z_OK if all goes well. You generally don't need to check the return code.</returns>
+        public int InitializeDeflate()
+        {
+            return _InternalInitializeDeflate(true);
+        }
+
+        /// <summary>
+        /// Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel.
+        /// </summary>
+        /// <remarks>
+        /// The codec will use the maximum window bits (15) and the specified
+        /// CompressionLevel.  It will emit a ZLIB stream as it compresses.
+        /// </remarks>
+        /// <param name="level">The compression level for the codec.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        public int InitializeDeflate(CompressionLevel level)
+        {
+            this.CompressLevel = level;
+            return _InternalInitializeDeflate(true);
+        }
+
+
+        /// <summary>
+        /// Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel, 
+        /// and the explicit flag governing whether to emit an RFC1950 header byte pair.
+        /// </summary>
+        /// <remarks>
+        /// The codec will use the maximum window bits (15) and the specified CompressionLevel.
+        /// If you want to generate a zlib stream, you should specify true for
+        /// wantRfc1950Header. In this case, the library will emit a ZLIB
+        /// header, as defined in <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC
+        /// 1950</see>, in the compressed stream.  
+        /// </remarks>
+        /// <param name="level">The compression level for the codec.</param>
+        /// <param name="wantRfc1950Header">whether to emit an initial RFC1950 byte pair in the compressed stream.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        public int InitializeDeflate(CompressionLevel level, bool wantRfc1950Header)
+        {
+            this.CompressLevel = level;
+            return _InternalInitializeDeflate(wantRfc1950Header);
+        }
+
+
+        /// <summary>
+        /// Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel, 
+        /// and the specified number of window bits. 
+        /// </summary>
+        /// <remarks>
+        /// The codec will use the specified number of window bits and the specified CompressionLevel.
+        /// </remarks>
+        /// <param name="level">The compression level for the codec.</param>
+        /// <param name="bits">the number of window bits to use.  If you don't know what this means, don't use this method.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        public int InitializeDeflate(CompressionLevel level, int bits)
+        {
+            this.CompressLevel = level;
+            this.WindowBits = bits;
+            return _InternalInitializeDeflate(true);
+        }
+
+        /// <summary>
+        /// Initialize the ZlibCodec for deflation operation, using the specified
+        /// CompressionLevel, the specified number of window bits, and the explicit flag
+        /// governing whether to emit an RFC1950 header byte pair.
+        /// </summary>
+        ///
+        /// <param name="level">The compression level for the codec.</param>
+        /// <param name="wantRfc1950Header">whether to emit an initial RFC1950 byte pair in the compressed stream.</param>
+        /// <param name="bits">the number of window bits to use.  If you don't know what this means, don't use this method.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        public int InitializeDeflate(CompressionLevel level, int bits, bool wantRfc1950Header)
+        {
+            this.CompressLevel = level;
+            this.WindowBits = bits;
+            return _InternalInitializeDeflate(wantRfc1950Header);
+        }
+
+        private int _InternalInitializeDeflate(bool wantRfc1950Header)
+        {
+            if (istate != null) throw new ZlibException("You may not call InitializeDeflate() after calling InitializeInflate().");
+            dstate = new DeflateManager();
+            dstate.WantRfc1950HeaderBytes = wantRfc1950Header;
+
+            return dstate.Initialize(this, this.CompressLevel, this.WindowBits, this.Strategy);
+        }
+
+        /// <summary>
+        /// Deflate one batch of data.
+        /// </summary>
+        /// <remarks>
+        /// You must have set InputBuffer and OutputBuffer before calling this method.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// private void DeflateBuffer(CompressionLevel level)
+        /// {
+        ///     int bufferSize = 1024;
+        ///     byte[] buffer = new byte[bufferSize];
+        ///     ZlibCodec compressor = new ZlibCodec();
+        /// 
+        ///     Console.WriteLine("\n============================================");
+        ///     Console.WriteLine("Size of Buffer to Deflate: {0} bytes.", UncompressedBytes.Length);
+        ///     MemoryStream ms = new MemoryStream();
+        /// 
+        ///     int rc = compressor.InitializeDeflate(level);
+        /// 
+        ///     compressor.InputBuffer = UncompressedBytes;
+        ///     compressor.NextIn = 0;
+        ///     compressor.AvailableBytesIn = UncompressedBytes.Length;
+        /// 
+        ///     compressor.OutputBuffer = buffer;
+        /// 
+        ///     // pass 1: deflate 
+        ///     do
+        ///     {
+        ///         compressor.NextOut = 0;
+        ///         compressor.AvailableBytesOut = buffer.Length;
+        ///         rc = compressor.Deflate(FlushType.None);
+        /// 
+        ///         if (rc != ZlibConstants.Z_OK &amp;&amp; rc != ZlibConstants.Z_STREAM_END)
+        ///             throw new Exception("deflating: " + compressor.Message);
+        /// 
+        ///         ms.Write(compressor.OutputBuffer, 0, buffer.Length - compressor.AvailableBytesOut);
+        ///     }
+        ///     while (compressor.AvailableBytesIn &gt; 0 || compressor.AvailableBytesOut == 0);
+        /// 
+        ///     // pass 2: finish and flush
+        ///     do
+        ///     {
+        ///         compressor.NextOut = 0;
+        ///         compressor.AvailableBytesOut = buffer.Length;
+        ///         rc = compressor.Deflate(FlushType.Finish);
+        /// 
+        ///         if (rc != ZlibConstants.Z_STREAM_END &amp;&amp; rc != ZlibConstants.Z_OK)
+        ///             throw new Exception("deflating: " + compressor.Message);
+        /// 
+        ///         if (buffer.Length - compressor.AvailableBytesOut &gt; 0)
+        ///             ms.Write(buffer, 0, buffer.Length - compressor.AvailableBytesOut);
+        ///     }
+        ///     while (compressor.AvailableBytesIn &gt; 0 || compressor.AvailableBytesOut == 0);
+        /// 
+        ///     compressor.EndDeflate();
+        /// 
+        ///     ms.Seek(0, SeekOrigin.Begin);
+        ///     CompressedBytes = new byte[compressor.TotalBytesOut];
+        ///     ms.Read(CompressedBytes, 0, CompressedBytes.Length);
+        /// }
+        /// </code>
+        /// </example>
+        /// <param name="flush">whether to flush all data as you deflate. Generally you will want to 
+        /// use Z_NO_FLUSH here, in a series of calls to Deflate(), and then call EndDeflate() to 
+        /// flush everything. 
+        /// </param>
+        /// <returns>Z_OK if all goes well.</returns>
+        public int Deflate(FlushType flush)
+        {
+            if (dstate == null)
+                throw new ZlibException("No Deflate State!");
+            return dstate.Deflate(flush);
+        }
+
+        /// <summary>
+        /// End a deflation session.
+        /// </summary>
+        /// <remarks>
+        /// Call this after making a series of one or more calls to Deflate(). All buffers are flushed.
+        /// </remarks>
+        /// <returns>Z_OK if all goes well.</returns>
+        public int EndDeflate()
+        {
+            if (dstate == null)
+                throw new ZlibException("No Deflate State!");
+            // TODO: dinoch Tue, 03 Nov 2009  15:39 (test this)
+            //int ret = dstate.End();
+            dstate = null;
+            return ZlibConstants.Z_OK; //ret;
+        }
+
+        /// <summary>
+        /// Reset a codec for another deflation session.
+        /// </summary>
+        /// <remarks>
+        /// Call this to reset the deflation state.  For example if a thread is deflating
+        /// non-consecutive blocks, you can call Reset() after the Deflate(Sync) of the first
+        /// block and before the next Deflate(None) of the second block.
+        /// </remarks>
+        /// <returns>Z_OK if all goes well.</returns>
+        public void ResetDeflate()
+        {
+            if (dstate == null)
+                throw new ZlibException("No Deflate State!");
+            dstate.Reset();
+        }
+
+
+        /// <summary>
+        /// Set the CompressionStrategy and CompressionLevel for a deflation session.
+        /// </summary>
+        /// <param name="level">the level of compression to use.</param>
+        /// <param name="strategy">the strategy to use for compression.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        public int SetDeflateParams(CompressionLevel level, CompressionStrategy strategy)
+        {
+            if (dstate == null)
+                throw new ZlibException("No Deflate State!");
+            return dstate.SetParams(level, strategy);
+        }
+
+
+        /// <summary>
+        /// Set the dictionary to be used for either Inflation or Deflation.
+        /// </summary>
+        /// <param name="dictionary">The dictionary bytes to use.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        public int SetDictionary(byte[] dictionary)
+        {
+            if (istate != null)
+                return istate.SetDictionary(dictionary);
+
+            if (dstate != null)
+                return dstate.SetDictionary(dictionary);
+
+            throw new ZlibException("No Inflate or Deflate state!");
+        }
+
+        // Flush as much pending output as possible. All deflate() output goes
+        // through this function so some applications may wish to modify it
+        // to avoid allocating a large strm->next_out buffer and copying into it.
+        // (See also read_buf()).
+        internal void flush_pending()
+        {
+            int len = dstate.pendingCount;
+
+            if (len > AvailableBytesOut)
+                len = AvailableBytesOut;
+            if (len == 0)
+                return;
+
+            if (dstate.pending.Length <= dstate.nextPending ||
+                OutputBuffer.Length <= NextOut ||
+                dstate.pending.Length < (dstate.nextPending + len) ||
+                OutputBuffer.Length < (NextOut + len))
+            {
+                throw new ZlibException(String.Format("Invalid State. (pending.Length={0}, pendingCount={1})",
+                    dstate.pending.Length, dstate.pendingCount));
+            }
+
+            Array.Copy(dstate.pending, dstate.nextPending, OutputBuffer, NextOut, len);
+
+            NextOut             += len;
+            dstate.nextPending  += len;
+            TotalBytesOut       += len;
+            AvailableBytesOut   -= len;
+            dstate.pendingCount -= len;
+            if (dstate.pendingCount == 0)
+            {
+                dstate.nextPending = 0;
+            }
+        }
+
+        // Read a new buffer from the current input stream, update the adler32
+        // and total number of bytes read.  All deflate() input goes through
+        // this function so some applications may wish to modify it to avoid
+        // allocating a large strm->next_in buffer and copying from it.
+        // (See also flush_pending()).
+        internal int read_buf(byte[] buf, int start, int size)
+        {
+            int len = AvailableBytesIn;
+
+            if (len > size)
+                len = size;
+            if (len == 0)
+                return 0;
+
+            AvailableBytesIn -= len;
+
+            if (dstate.WantRfc1950HeaderBytes)
+            {
+                _Adler32 = Adler.Adler32(_Adler32, InputBuffer, NextIn, len);
+            }
+            Array.Copy(InputBuffer, NextIn, buf, start, len);
+            NextIn += len;
+            TotalBytesIn += len;
+            return len;
+        }
+
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Deflate/ZlibConstants.cs b/MonoGame.Framework/Utilities/Deflate/ZlibConstants.cs
new file mode 100644
index 00000000000..f48760b5ebc
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Deflate/ZlibConstants.cs
@@ -0,0 +1,128 @@
+// ZlibConstants.cs
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.  
+// All rights reserved.
+//
+// This code module is part of DotNetZip, a zipfile class library.
+//
+// ------------------------------------------------------------------
+//
+// This code is licensed under the Microsoft Public License. 
+// See the file License.txt for the license details.
+// More info on: http://dotnetzip.codeplex.com
+//
+// ------------------------------------------------------------------
+//
+// last saved (in emacs): 
+// Time-stamp: <2009-November-03 18:50:19>
+//
+// ------------------------------------------------------------------
+//
+// This module defines constants used by the zlib class library.  This
+// code is derived from the jzlib implementation of zlib, but
+// significantly modified.  In keeping with the license for jzlib, the
+// copyright to that code is included here.
+//
+// ------------------------------------------------------------------
+// 
+// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright 
+// notice, this list of conditions and the following disclaimer in 
+// the documentation and/or other materials provided with the distribution.
+// 
+// 3. The names of the authors may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+// -----------------------------------------------------------------------
+//
+// This program is based on zlib-1.1.3; credit to authors
+// Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+// and contributors of zlib.
+//
+// -----------------------------------------------------------------------
+
+
+using System;
+
+namespace MonoGame.Utilities.Deflate
+{
+    /// <summary>
+    /// A bunch of constants used in the Zlib interface.
+    /// </summary>
+    public static class ZlibConstants
+    {
+        /// <summary>
+        /// The maximum number of window bits for the Deflate algorithm.
+        /// </summary>
+        public const int WindowBitsMax = 15; // 32K LZ77 window
+
+        /// <summary>
+        /// The default number of window bits for the Deflate algorithm.
+        /// </summary>
+        public const int WindowBitsDefault = WindowBitsMax;
+
+        /// <summary>
+        /// indicates everything is A-OK
+        /// </summary>
+        public const int Z_OK = 0;
+
+        /// <summary>
+        /// Indicates that the last operation reached the end of the stream.
+        /// </summary>
+        public const int Z_STREAM_END = 1;
+
+        /// <summary>
+        /// The operation ended in need of a dictionary. 
+        /// </summary>
+        public const int Z_NEED_DICT = 2;
+
+        /// <summary>
+        /// There was an error with the stream - not enough data, not open and readable, etc.
+        /// </summary>
+        public const int Z_STREAM_ERROR = -2;
+
+        /// <summary>
+        /// There was an error with the data - not enough data, bad data, etc.
+        /// </summary>
+        public const int Z_DATA_ERROR = -3;
+
+        /// <summary>
+        /// There was an error with the working buffer.
+        /// </summary>
+        public const int Z_BUF_ERROR = -5;
+
+        /// <summary>
+        /// The size of the working buffer used in the ZlibCodec class. Defaults to 8192 bytes.
+        /// </summary>
+#if NETCF        
+        public const int WorkingBufferSizeDefault = 8192;
+#else
+        public const int WorkingBufferSizeDefault = 16384; 
+#endif
+        /// <summary>
+        /// The minimum size of the working buffer used in the ZlibCodec class.  Currently it is 128 bytes.
+        /// </summary>
+        public const int WorkingBufferSizeMin = 1024;
+    }
+
+}
+
diff --git a/MonoGame.Framework/Utilities/Deflate/ZlibStream.cs b/MonoGame.Framework/Utilities/Deflate/ZlibStream.cs
new file mode 100644
index 00000000000..baf6d243397
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Deflate/ZlibStream.cs
@@ -0,0 +1,725 @@
+// ZlibStream.cs
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
+// All rights reserved.
+//
+// This code module is part of DotNetZip, a zipfile class library.
+//
+// ------------------------------------------------------------------
+//
+// This code is licensed under the Microsoft Public License.
+// See the file License.txt for the license details.
+// More info on: http://dotnetzip.codeplex.com
+//
+// ------------------------------------------------------------------
+//
+// last saved (in emacs):
+// Time-stamp: <2011-July-31 14:53:33>
+//
+// ------------------------------------------------------------------
+//
+// This module defines the ZlibStream class, which is similar in idea to
+// the System.IO.Compression.DeflateStream and
+// System.IO.Compression.GZipStream classes in the .NET BCL.
+//
+// ------------------------------------------------------------------
+
+using System;
+using System.IO;
+
+namespace MonoGame.Utilities.Deflate
+{
+
+    /// <summary>
+    /// Represents a Zlib stream for compression or decompression.
+    /// </summary>
+    /// <remarks>
+    ///
+    /// <para>
+    /// The ZlibStream is a <see
+    /// href="http://en.wikipedia.org/wiki/Decorator_pattern">Decorator</see> on a <see
+    /// cref="System.IO.Stream"/>.  It adds ZLIB compression or decompression to any
+    /// stream.
+    /// </para>
+    ///
+    /// <para> Using this stream, applications can compress or decompress data via
+    /// stream <c>Read()</c> and <c>Write()</c> operations.  Either compression or
+    /// decompression can occur through either reading or writing. The compression
+    /// format used is ZLIB, which is documented in <see
+    /// href="http://www.ietf.org/rfc/rfc1950.txt">IETF RFC 1950</see>, "ZLIB Compressed
+    /// Data Format Specification version 3.3". This implementation of ZLIB always uses
+    /// DEFLATE as the compression method.  (see <see
+    /// href="http://www.ietf.org/rfc/rfc1951.txt">IETF RFC 1951</see>, "DEFLATE
+    /// Compressed Data Format Specification version 1.3.") </para>
+    ///
+    /// <para>
+    /// The ZLIB format allows for varying compression methods, window sizes, and dictionaries.
+    /// This implementation always uses the DEFLATE compression method, a preset dictionary,
+    /// and 15 window bits by default.
+    /// </para>
+    ///
+    /// <para>
+    /// This class is similar to <see cref="DeflateStream"/>, except that it adds the
+    /// RFC1950 header and trailer bytes to a compressed stream when compressing, or expects
+    /// the RFC1950 header and trailer bytes when decompressing.  It is also similar to the
+    /// <see cref="GZipStream"/>.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="DeflateStream" />
+    /// <seealso cref="GZipStream" />
+    public class ZlibStream : System.IO.Stream
+    {
+        internal ZlibBaseStream _baseStream;
+        bool _disposed;
+
+        /// <summary>
+        /// Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>.
+        /// </summary>
+        /// <remarks>
+        ///
+        /// <para>
+        ///   When mode is <c>CompressionMode.Compress</c>, the <c>ZlibStream</c>
+        ///   will use the default compression level. The "captive" stream will be
+        ///   closed when the <c>ZlibStream</c> is closed.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        /// This example uses a <c>ZlibStream</c> to compress a file, and writes the
+        /// compressed data to another file.
+        /// <code>
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        /// {
+        ///     using (var raw = System.IO.File.Create(fileToCompress + ".zlib"))
+        ///     {
+        ///         using (Stream compressor = new ZlibStream(raw, CompressionMode.Compress))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n;
+        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
+        ///             {
+        ///                 compressor.Write(buffer, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        /// <code lang="VB">
+        /// Using input As Stream = File.OpenRead(fileToCompress)
+        ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".zlib")
+        ///     Using compressor As Stream = New ZlibStream(raw, CompressionMode.Compress)
+        ///         Dim buffer As Byte() = New Byte(4096) {}
+        ///         Dim n As Integer = -1
+        ///         Do While (n &lt;&gt; 0)
+        ///             If (n &gt; 0) Then
+        ///                 compressor.Write(buffer, 0, n)
+        ///             End If
+        ///             n = input.Read(buffer, 0, buffer.Length)
+        ///         Loop
+        ///     End Using
+        ///     End Using
+        /// End Using
+        /// </code>
+        /// </example>
+        ///
+        /// <param name="stream">The stream which will be read or written.</param>
+        /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
+        public ZlibStream(System.IO.Stream stream, CompressionMode mode)
+            : this(stream, mode, CompressionLevel.Default, false)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c> and
+        ///   the specified <c>CompressionLevel</c>.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   When mode is <c>CompressionMode.Decompress</c>, the level parameter is ignored.
+        ///   The "captive" stream will be closed when the <c>ZlibStream</c> is closed.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        ///   This example uses a <c>ZlibStream</c> to compress data from a file, and writes the
+        ///   compressed data to another file.
+        ///
+        /// <code>
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        /// {
+        ///     using (var raw = System.IO.File.Create(fileToCompress + ".zlib"))
+        ///     {
+        ///         using (Stream compressor = new ZlibStream(raw,
+        ///                                                   CompressionMode.Compress,
+        ///                                                   CompressionLevel.BestCompression))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n;
+        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
+        ///             {
+        ///                 compressor.Write(buffer, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        ///
+        /// <code lang="VB">
+        /// Using input As Stream = File.OpenRead(fileToCompress)
+        ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".zlib")
+        ///         Using compressor As Stream = New ZlibStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
+        ///             Dim buffer As Byte() = New Byte(4096) {}
+        ///             Dim n As Integer = -1
+        ///             Do While (n &lt;&gt; 0)
+        ///                 If (n &gt; 0) Then
+        ///                     compressor.Write(buffer, 0, n)
+        ///                 End If
+        ///                 n = input.Read(buffer, 0, buffer.Length)
+        ///             Loop
+        ///         End Using
+        ///     End Using
+        /// End Using
+        /// </code>
+        /// </example>
+        ///
+        /// <param name="stream">The stream to be read or written while deflating or inflating.</param>
+        /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
+        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
+        public ZlibStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level)
+            : this(stream, mode, level, false)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>, and
+        ///   explicitly specify whether the captive stream should be left open after
+        ///   Deflation or Inflation.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   When mode is <c>CompressionMode.Compress</c>, the <c>ZlibStream</c> will use
+        ///   the default compression level.
+        /// </para>
+        ///
+        /// <para>
+        ///   This constructor allows the application to request that the captive stream
+        ///   remain open after the deflation or inflation occurs.  By default, after
+        ///   <c>Close()</c> is called on the stream, the captive stream is also
+        ///   closed. In some cases this is not desired, for example if the stream is a
+        ///   <see cref="System.IO.MemoryStream"/> that will be re-read after
+        ///   compression.  Specify true for the <paramref name="leaveOpen"/> parameter to leave the stream
+        ///   open.
+        /// </para>
+        ///
+        /// <para>
+        /// See the other overloads of this constructor for example code.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <param name="stream">The stream which will be read or written. This is called the
+        /// "captive" stream in other places in this documentation.</param>
+        /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
+        /// <param name="leaveOpen">true if the application would like the stream to remain
+        /// open after inflation/deflation.</param>
+        public ZlibStream(System.IO.Stream stream, CompressionMode mode, bool leaveOpen)
+            : this(stream, mode, CompressionLevel.Default, leaveOpen)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>
+        ///   and the specified <c>CompressionLevel</c>, and explicitly specify
+        ///   whether the stream should be left open after Deflation or Inflation.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   This constructor allows the application to request that the captive
+        ///   stream remain open after the deflation or inflation occurs.  By
+        ///   default, after <c>Close()</c> is called on the stream, the captive
+        ///   stream is also closed. In some cases this is not desired, for example
+        ///   if the stream is a <see cref="System.IO.MemoryStream"/> that will be
+        ///   re-read after compression.  Specify true for the <paramref
+        ///   name="leaveOpen"/> parameter to leave the stream open.
+        /// </para>
+        ///
+        /// <para>
+        ///   When mode is <c>CompressionMode.Decompress</c>, the level parameter is
+        ///   ignored.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        ///
+        /// This example shows how to use a ZlibStream to compress the data from a file,
+        /// and store the result into another file. The filestream remains open to allow
+        /// additional data to be written to it.
+        ///
+        /// <code>
+        /// using (var output = System.IO.File.Create(fileToCompress + ".zlib"))
+        /// {
+        ///     using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        ///     {
+        ///         using (Stream compressor = new ZlibStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, true))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n;
+        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
+        ///             {
+        ///                 compressor.Write(buffer, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        ///     // can write additional data to the output stream here
+        /// }
+        /// </code>
+        /// <code lang="VB">
+        /// Using output As FileStream = File.Create(fileToCompress &amp; ".zlib")
+        ///     Using input As Stream = File.OpenRead(fileToCompress)
+        ///         Using compressor As Stream = New ZlibStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, True)
+        ///             Dim buffer As Byte() = New Byte(4096) {}
+        ///             Dim n As Integer = -1
+        ///             Do While (n &lt;&gt; 0)
+        ///                 If (n &gt; 0) Then
+        ///                     compressor.Write(buffer, 0, n)
+        ///                 End If
+        ///                 n = input.Read(buffer, 0, buffer.Length)
+        ///             Loop
+        ///         End Using
+        ///     End Using
+        ///     ' can write additional data to the output stream here.
+        /// End Using
+        /// </code>
+        /// </example>
+        ///
+        /// <param name="stream">The stream which will be read or written.</param>
+        ///
+        /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
+        ///
+        /// <param name="leaveOpen">
+        /// true if the application would like the stream to remain open after
+        /// inflation/deflation.
+        /// </param>
+        ///
+        /// <param name="level">
+        /// A tuning knob to trade speed for effectiveness. This parameter is
+        /// effective only when mode is <c>CompressionMode.Compress</c>.
+        /// </param>
+        public ZlibStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
+        {
+            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.ZLIB, leaveOpen);
+        }
+
+        #region Zlib properties
+
+        /// <summary>
+        /// This property sets the flush behavior on the stream.
+        /// Sorry, though, not sure exactly how to describe all the various settings.
+        /// </summary>
+        virtual public FlushType FlushMode
+        {
+            get { return (this._baseStream._flushMode); }
+            set
+            {
+                if (_disposed) throw new ObjectDisposedException("ZlibStream");
+                this._baseStream._flushMode = value;
+            }
+        }
+
+        /// <summary>
+        ///   The size of the working buffer for the compression codec.
+        /// </summary>
+        ///
+        /// <remarks>
+        /// <para>
+        ///   The working buffer is used for all stream operations.  The default size is
+        ///   1024 bytes. The minimum size is 128 bytes. You may get better performance
+        ///   with a larger buffer.  Then again, you might not.  You would have to test
+        ///   it.
+        /// </para>
+        ///
+        /// <para>
+        ///   Set this before the first call to <c>Read()</c> or <c>Write()</c> on the
+        ///   stream. If you try to set it afterwards, it will throw.
+        /// </para>
+        /// </remarks>
+        public int BufferSize
+        {
+            get
+            {
+                return this._baseStream._bufferSize;
+            }
+            set
+            {
+                if (_disposed) throw new ObjectDisposedException("ZlibStream");
+                if (this._baseStream._workingBuffer != null)
+                    throw new ZlibException("The working buffer is already set.");
+                if (value < ZlibConstants.WorkingBufferSizeMin)
+                    throw new ZlibException(String.Format("Don't be silly. {0} bytes?? Use a bigger buffer, at least {1}.", value, ZlibConstants.WorkingBufferSizeMin));
+                this._baseStream._bufferSize = value;
+            }
+        }
+
+        /// <summary> Returns the total number of bytes input so far.</summary>
+        virtual public long TotalIn
+        {
+            get { return this._baseStream._z.TotalBytesIn; }
+        }
+
+        /// <summary> Returns the total number of bytes output so far.</summary>
+        virtual public long TotalOut
+        {
+            get { return this._baseStream._z.TotalBytesOut; }
+        }
+
+        #endregion
+
+        #region System.IO.Stream methods
+
+        /// <summary>
+        ///   Dispose the stream.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     This may or may not result in a <c>Close()</c> call on the captive
+        ///     stream.  See the constructors that have a <c>leaveOpen</c> parameter
+        ///     for more information.
+        ///   </para>
+        ///   <para>
+        ///     This method may be invoked in two distinct scenarios.  If disposing
+        ///     == true, the method has been called directly or indirectly by a
+        ///     user's code, for example via the public Dispose() method. In this
+        ///     case, both managed and unmanaged resources can be referenced and
+        ///     disposed.  If disposing == false, the method has been called by the
+        ///     runtime from inside the object finalizer and this method should not
+        ///     reference other objects; in that case only unmanaged resources must
+        ///     be referenced or disposed.
+        ///   </para>
+        /// </remarks>
+        /// <param name="disposing">
+        ///   indicates whether the Dispose method was invoked by user code.
+        /// </param>
+        protected override void Dispose(bool disposing)
+        {
+            try
+            {
+                if (!_disposed)
+                {
+                    if (disposing && (this._baseStream != null))
+                        this._baseStream.Close();
+                    _disposed = true;
+                }
+            }
+            finally
+            {
+                base.Dispose(disposing);
+            }
+        }
+
+
+        /// <summary>
+        /// Indicates whether the stream can be read.
+        /// </summary>
+        /// <remarks>
+        /// The return value depends on whether the captive stream supports reading.
+        /// </remarks>
+        public override bool CanRead
+        {
+            get
+            {
+                if (_disposed) throw new ObjectDisposedException("ZlibStream");
+                return _baseStream._stream.CanRead;
+            }
+        }
+
+        /// <summary>
+        /// Indicates whether the stream supports Seek operations.
+        /// </summary>
+        /// <remarks>
+        /// Always returns false.
+        /// </remarks>
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// Indicates whether the stream can be written.
+        /// </summary>
+        /// <remarks>
+        /// The return value depends on whether the captive stream supports writing.
+        /// </remarks>
+        public override bool CanWrite
+        {
+            get
+            {
+                if (_disposed) throw new ObjectDisposedException("ZlibStream");
+                return _baseStream._stream.CanWrite;
+            }
+        }
+
+        /// <summary>
+        /// Flush the stream.
+        /// </summary>
+        public override void Flush()
+        {
+            if (_disposed) throw new ObjectDisposedException("ZlibStream");
+            _baseStream.Flush();
+        }
+
+        /// <summary>
+        /// Reading this property always throws a <see cref="NotSupportedException"/>.
+        /// </summary>
+        public override long Length
+        {
+            get { throw new NotSupportedException(); }
+        }
+
+        /// <summary>
+        ///   The position of the stream pointer.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Setting this property always throws a <see
+        ///   cref="NotSupportedException"/>. Reading will return the total bytes
+        ///   written out, if used in writing, or the total bytes read in, if used in
+        ///   reading.  The count may refer to compressed bytes or uncompressed bytes,
+        ///   depending on how you've used the stream.
+        /// </remarks>
+        public override long Position
+        {
+            get
+            {
+                if (this._baseStream._streamMode == MonoGame.Utilities.Deflate.ZlibBaseStream.StreamMode.Writer)
+                    return this._baseStream._z.TotalBytesOut;
+                if (this._baseStream._streamMode == MonoGame.Utilities.Deflate.ZlibBaseStream.StreamMode.Reader)
+                    return this._baseStream._z.TotalBytesIn;
+                return 0;
+            }
+
+            set { throw new NotSupportedException(); }
+        }
+
+        /// <summary>
+        /// Read data from the stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   If you wish to use the <c>ZlibStream</c> to compress data while reading,
+        ///   you can create a <c>ZlibStream</c> with <c>CompressionMode.Compress</c>,
+        ///   providing an uncompressed data stream.  Then call <c>Read()</c> on that
+        ///   <c>ZlibStream</c>, and the data read will be compressed.  If you wish to
+        ///   use the <c>ZlibStream</c> to decompress data while reading, you can create
+        ///   a <c>ZlibStream</c> with <c>CompressionMode.Decompress</c>, providing a
+        ///   readable compressed data stream.  Then call <c>Read()</c> on that
+        ///   <c>ZlibStream</c>, and the data will be decompressed as it is read.
+        /// </para>
+        ///
+        /// <para>
+        ///   A <c>ZlibStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but
+        ///   not both.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <param name="buffer">
+        /// The buffer into which the read data should be placed.</param>
+        ///
+        /// <param name="offset">
+        /// the offset within that data array to put the first byte read.</param>
+        ///
+        /// <param name="count">the number of bytes to read.</param>
+        ///
+        /// <returns>the number of bytes read</returns>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+                if (_disposed) throw new ObjectDisposedException("ZlibStream");
+            return _baseStream.Read(buffer, offset, count);
+        }
+
+        /// <summary>
+        /// Calling this method always throws a <see cref="NotSupportedException"/>.
+        /// </summary>
+        /// <param name="offset">
+        ///   The offset to seek to....
+        ///   IF THIS METHOD ACTUALLY DID ANYTHING.
+        /// </param>
+        /// <param name="origin">
+        ///   The reference specifying how to apply the offset....  IF
+        ///   THIS METHOD ACTUALLY DID ANYTHING.
+        /// </param>
+        ///
+        /// <returns>nothing. This method always throws.</returns>
+        public override long Seek(long offset, System.IO.SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Calling this method always throws a <see cref="NotSupportedException"/>.
+        /// </summary>
+        /// <param name="value">
+        ///   The new value for the stream length....  IF
+        ///   THIS METHOD ACTUALLY DID ANYTHING.
+        /// </param>
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Write data to the stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   If you wish to use the <c>ZlibStream</c> to compress data while writing,
+        ///   you can create a <c>ZlibStream</c> with <c>CompressionMode.Compress</c>,
+        ///   and a writable output stream.  Then call <c>Write()</c> on that
+        ///   <c>ZlibStream</c>, providing uncompressed data as input.  The data sent to
+        ///   the output stream will be the compressed form of the data written.  If you
+        ///   wish to use the <c>ZlibStream</c> to decompress data while writing, you
+        ///   can create a <c>ZlibStream</c> with <c>CompressionMode.Decompress</c>, and a
+        ///   writable output stream.  Then call <c>Write()</c> on that stream,
+        ///   providing previously compressed data. The data sent to the output stream
+        ///   will be the decompressed form of the data written.
+        /// </para>
+        ///
+        /// <para>
+        ///   A <c>ZlibStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but not both.
+        /// </para>
+        /// </remarks>
+        /// <param name="buffer">The buffer holding data to write to the stream.</param>
+        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
+        /// <param name="count">the number of bytes to write.</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+                if (_disposed) throw new ObjectDisposedException("ZlibStream");
+            _baseStream.Write(buffer, offset, count);
+        }
+        #endregion
+
+
+        /// <summary>
+        ///   Compress a string into a byte array using ZLIB.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Uncompress it with <see cref="ZlibStream.UncompressString(byte[])"/>.
+        /// </remarks>
+        ///
+        /// <seealso cref="ZlibStream.UncompressString(byte[])"/>
+        /// <seealso cref="ZlibStream.CompressBuffer(byte[])"/>
+        /// <seealso cref="GZipStream.CompressString(string)"/>
+        ///
+        /// <param name="s">
+        ///   A string to compress.  The string will first be encoded
+        ///   using UTF8, then compressed.
+        /// </param>
+        ///
+        /// <returns>The string in compressed form</returns>
+        public static byte[] CompressString(String s)
+        {
+            using (var ms = new MemoryStream())
+            {
+                Stream compressor =
+                    new ZlibStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression);
+                ZlibBaseStream.CompressString(s, compressor);
+                return ms.ToArray();
+            }
+        }
+
+
+        /// <summary>
+        ///   Compress a byte array into a new byte array using ZLIB.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Uncompress it with <see cref="ZlibStream.UncompressBuffer(byte[])"/>.
+        /// </remarks>
+        ///
+        /// <seealso cref="ZlibStream.CompressString(string)"/>
+        /// <seealso cref="ZlibStream.UncompressBuffer(byte[])"/>
+        ///
+        /// <param name="b">
+        /// A buffer to compress.
+        /// </param>
+        ///
+        /// <returns>The data in compressed form</returns>
+        public static byte[] CompressBuffer(byte[] b)
+        {
+            using (var ms = new MemoryStream())
+            {
+                Stream compressor =
+                    new ZlibStream( ms, CompressionMode.Compress, CompressionLevel.BestCompression );
+
+                ZlibBaseStream.CompressBuffer(b, compressor);
+                return ms.ToArray();
+            }
+        }
+
+
+        /// <summary>
+        ///   Uncompress a ZLIB-compressed byte array into a single string.
+        /// </summary>
+        ///
+        /// <seealso cref="ZlibStream.CompressString(String)"/>
+        /// <seealso cref="ZlibStream.UncompressBuffer(byte[])"/>
+        ///
+        /// <param name="compressed">
+        ///   A buffer containing ZLIB-compressed data.
+        /// </param>
+        ///
+        /// <returns>The uncompressed string</returns>
+        public static String UncompressString(byte[] compressed)
+        {
+            using (var input = new MemoryStream(compressed))
+            {
+                Stream decompressor =
+                    new ZlibStream(input, CompressionMode.Decompress);
+
+                return ZlibBaseStream.UncompressString(compressed, decompressor);
+            }
+        }
+
+
+        /// <summary>
+        ///   Uncompress a ZLIB-compressed byte array into a byte array.
+        /// </summary>
+        ///
+        /// <seealso cref="ZlibStream.CompressBuffer(byte[])"/>
+        /// <seealso cref="ZlibStream.UncompressString(byte[])"/>
+        ///
+        /// <param name="compressed">
+        ///   A buffer containing ZLIB-compressed data.
+        /// </param>
+        ///
+        /// <returns>The data in uncompressed form</returns>
+        public static byte[] UncompressBuffer(byte[] compressed)
+        {
+            using (var input = new MemoryStream(compressed))
+            {
+                Stream decompressor =
+                    new ZlibStream( input, CompressionMode.Decompress );
+
+                return ZlibBaseStream.UncompressBuffer(compressed, decompressor);
+            }
+        }
+
+    }
+
+
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/FileHelpers.cs b/MonoGame.Framework/Utilities/FileHelpers.cs
new file mode 100644
index 00000000000..ea8cb49b0dc
--- /dev/null
+++ b/MonoGame.Framework/Utilities/FileHelpers.cs
@@ -0,0 +1,90 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using System.Text;
+
+namespace MonoGame.Utilities
+{
+    internal static class FileHelpers
+    {
+        private static readonly char[] UrlSafeChars = new[] { '.', '_', '-', ';', '/', '?', '\\', ':' };
+
+        public static readonly char ForwardSlash = '/';
+        public static readonly string ForwardSlashString = new string(ForwardSlash, 1);
+        public static readonly char BackwardSlash = '\\';
+
+#if WINDOWS_UAP
+        public static readonly char NotSeparator = ForwardSlash;
+        public static readonly char Separator = BackwardSlash;
+#else
+        public static readonly char NotSeparator = Path.DirectorySeparatorChar == BackwardSlash ? ForwardSlash : BackwardSlash;
+        public static readonly char Separator = Path.DirectorySeparatorChar;
+#endif
+
+        public static string NormalizeFilePathSeparators(string name)
+        {
+            return name.Replace(NotSeparator, Separator);
+        }
+
+        /// <summary>
+        /// Combines the filePath and relativeFile based on relativeFile being a file in the same location as filePath.
+        /// Relative directory operators (..) are also resolved
+        /// </summary>
+        /// <example>"A\B\C.txt","D.txt" becomes "A\B\D.txt"</example>
+        /// <example>"A\B\C.txt","..\D.txt" becomes "A\D.txt"</example>
+        /// <param name="filePath">Path to the file we are starting from</param>
+        /// <param name="relativeFile">Relative location of another file to resolve the path to</param>
+        public static string ResolveRelativePath(string filePath, string relativeFile)
+        {
+            // Uri accepts forward slashes
+            filePath = filePath.Replace(BackwardSlash, ForwardSlash);
+
+            bool hasForwardSlash = filePath.StartsWith(ForwardSlashString);
+            if (!hasForwardSlash)
+                filePath = ForwardSlashString + filePath;
+
+            // Get a uri for filePath using the file:// schema and no host.
+            var src = new Uri("file://" + UrlEncode(filePath));
+
+            var dst = new Uri(src, UrlEncode(relativeFile));
+
+            // The uri now contains the path to the relativeFile with 
+            // relative addresses resolved... get the local path.
+            var localPath = dst.LocalPath;
+
+            if (!hasForwardSlash && localPath.StartsWith("/"))
+                localPath = localPath.Substring(1);
+
+            // Convert the directory separator characters to the 
+            // correct platform specific separator.
+            return NormalizeFilePathSeparators(localPath);
+        }
+
+        private static string UrlEncode(string url)
+        {
+            var encoder = new UTF8Encoding();
+            var safeline = new StringBuilder(encoder.GetByteCount(url) * 3);
+
+            foreach (var c in url)
+            {
+                if ((c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || Array.IndexOf(UrlSafeChars, c) != -1)
+                    safeline.Append(c);
+                else
+                {
+                    var bytes = encoder.GetBytes(c.ToString());
+
+                    foreach (var num in bytes)
+                    {
+                        safeline.Append("%");
+                        safeline.Append(num.ToString("X"));
+                    }
+                }
+            }
+
+            return safeline.ToString();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/FuncLoader.Android.cs b/MonoGame.Framework/Utilities/FuncLoader.Android.cs
new file mode 100644
index 00000000000..9352b6d9d08
--- /dev/null
+++ b/MonoGame.Framework/Utilities/FuncLoader.Android.cs
@@ -0,0 +1,62 @@
+using Android.App;
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace MonoGame.Utilities
+{
+    internal class FuncLoader
+    {
+        [DllImport("dl")]
+        public static extern IntPtr dlopen(string path, int flags);
+
+        [DllImport("dl")]
+        public static extern IntPtr dlsym(IntPtr handle, string symbol);
+
+        private const int RTLD_LAZY = 0x0001;
+
+        public static IntPtr LoadLibrary(string libname)
+        {
+            // Let the OS search for the library by default.
+            IntPtr lib = dlopen(libname, RTLD_LAZY);
+            if (lib != IntPtr.Zero)
+            {
+                Console.WriteLine("FuncLoader.LoadLibrary {0}", libname);
+                return lib;
+            }
+
+            // Some Android devices won't search the native library path
+            // for the library, so we have to do it manually here.
+            var nlibpath = Application.Context.ApplicationInfo.NativeLibraryDir;
+            var libpath = Path.Combine(nlibpath, libname);
+            lib = dlopen(libpath, RTLD_LAZY);
+            if (lib != IntPtr.Zero)
+            {	
+                Console.WriteLine("FuncLoader.LoadLibrary {0}", libpath);
+                return lib;
+            }
+
+            Console.WriteLine("FuncLoader.LoadLibrary {0} Not Found!", libname);
+            return IntPtr.Zero;
+        }
+
+        public static T LoadFunction<T>(IntPtr library, string function, bool throwIfNotFound = false)
+        {
+            var ret = dlsym(library, function);
+
+            if (ret == IntPtr.Zero)
+            {
+                if (throwIfNotFound)
+                    throw new EntryPointNotFoundException(function);
+
+                return default(T);
+            }
+
+            // TODO: Use the function bellow once Protobuild gets axed
+            // requires .NET Framework 4.5.1 and its useful for corert
+            // return Marshal.GetDelegateForFunctionPointer<T>(ret);
+
+            return (T)(object)Marshal.GetDelegateForFunctionPointer(ret, typeof(T));
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/FuncLoader.Desktop.cs b/MonoGame.Framework/Utilities/FuncLoader.Desktop.cs
new file mode 100644
index 00000000000..f3553c1f0a8
--- /dev/null
+++ b/MonoGame.Framework/Utilities/FuncLoader.Desktop.cs
@@ -0,0 +1,74 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace MonoGame.Utilities
+{
+    internal class FuncLoader
+    {
+        private class Windows
+        {
+            [DllImport("kernel32", CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true)]
+            public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
+
+            [DllImport("kernel32", SetLastError = true, CharSet = CharSet.Unicode)]
+            public static extern IntPtr LoadLibraryW(string lpszLib);
+        }
+
+        private class Linux
+        {
+            [DllImport("libdl.so.2")]
+            public static extern IntPtr dlopen(string path, int flags);
+
+            [DllImport("libdl.so.2")]
+            public static extern IntPtr dlsym(IntPtr handle, string symbol);
+        }
+
+        private class OSX
+        {
+            [DllImport("/usr/lib/libSystem.dylib")]
+            public static extern IntPtr dlopen(string path, int flags);
+
+            [DllImport("/usr/lib/libSystem.dylib")]
+            public static extern IntPtr dlsym(IntPtr handle, string symbol);
+        }
+        
+        private const int RTLD_LAZY = 0x0001;
+
+        public static IntPtr LoadLibrary(string libname)
+        {
+            if (CurrentPlatform.OS == OS.Windows)
+                return Windows.LoadLibraryW(libname);
+
+            if (CurrentPlatform.OS == OS.MacOSX)
+                return OSX.dlopen(libname, RTLD_LAZY);
+
+            return Linux.dlopen(libname, RTLD_LAZY);
+        }
+
+        public static T LoadFunction<T>(IntPtr library, string function, bool throwIfNotFound = false)
+        {
+            var ret = IntPtr.Zero;
+
+            if (CurrentPlatform.OS == OS.Windows)
+                ret = Windows.GetProcAddress(library, function);
+            else if (CurrentPlatform.OS == OS.MacOSX)
+                ret = OSX.dlsym(library, function);
+            else
+                ret = Linux.dlsym(library, function);
+
+            if (ret == IntPtr.Zero)
+            {
+                if (throwIfNotFound)
+                    throw new EntryPointNotFoundException(function);
+
+                return default(T);
+            }
+
+#if NETSTANDARD
+            return Marshal.GetDelegateForFunctionPointer<T>(ret);
+#else
+            return (T)(object)Marshal.GetDelegateForFunctionPointer(ret, typeof(T));
+#endif
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/FuncLoader.iOS.cs b/MonoGame.Framework/Utilities/FuncLoader.iOS.cs
new file mode 100644
index 00000000000..6067e9ad355
--- /dev/null
+++ b/MonoGame.Framework/Utilities/FuncLoader.iOS.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Runtime.InteropServices;
+using ObjCRuntime;
+
+namespace MonoGame.Utilities
+{
+    internal class FuncLoader
+    {
+        public static IntPtr LoadLibrary(string libname)
+        {
+            return Dlfcn.dlopen(libname, 0);
+        }
+
+        public static T LoadFunction<T>(IntPtr library, string function, bool throwIfNotFound = false)
+        {
+            var ret = Dlfcn.dlsym(library, function);
+
+            if (ret == IntPtr.Zero)
+            {
+                if (throwIfNotFound)
+                    throw new EntryPointNotFoundException(function);
+
+                return default(T);
+            }
+
+            // TODO: Use the function bellow once Protobuild gets axed
+            // requires .NET Framework 4.5.1 and its useful for corert
+            // return Marshal.GetDelegateForFunctionPointer<T>(ret);
+
+            return (T)(object)Marshal.GetDelegateForFunctionPointer(ret, typeof(T));
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/Hash.cs b/MonoGame.Framework/Utilities/Hash.cs
new file mode 100644
index 00000000000..2744eef5787
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Hash.cs
@@ -0,0 +1,76 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.IO;
+
+namespace MonoGame.Utilities
+{
+    internal static class Hash
+    {
+        /// <summary>
+        /// Compute a hash from a byte array.
+        /// </summary>
+        /// <remarks>
+        /// Modified FNV Hash in C#
+        /// http://stackoverflow.com/a/468084
+        /// </remarks>
+        internal static int ComputeHash(params byte[] data)
+        {
+            unchecked
+            {
+                const int p = 16777619;
+                var hash = (int)2166136261;
+
+                for (var i = 0; i < data.Length; i++)
+                    hash = (hash ^ data[i]) * p;
+
+                hash += hash << 13;
+                hash ^= hash >> 7;
+                hash += hash << 3;
+                hash ^= hash >> 17;
+                hash += hash << 5;
+                return hash;
+            }
+        }
+        
+        /// <summary>
+        /// Compute a hash from the content of a stream and restore the position.
+        /// </summary>
+        /// <remarks>
+        /// Modified FNV Hash in C#
+        /// http://stackoverflow.com/a/468084
+        /// </remarks>
+        internal static int ComputeHash(Stream stream)
+        {
+            System.Diagnostics.Debug.Assert(stream.CanSeek);
+
+            unchecked
+            {
+                const int p = 16777619;
+                var hash = (int)2166136261;
+
+                var prevPosition = stream.Position;
+                stream.Position = 0;
+
+                var data = new byte[1024];
+                int length;
+                while((length = stream.Read(data, 0, data.Length)) != 0)
+                {
+                    for (var i = 0; i < length; i++)
+                        hash = (hash ^ data[i]) * p;
+                }
+
+                // Restore stream position.
+                stream.Position = prevPosition;
+
+                hash += hash << 13;
+                hash ^= hash >> 7;
+                hash += hash << 3;
+                hash ^= hash >> 17;
+                hash += hash << 5;
+                return hash;
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/Imaging/ImageReader.cs b/MonoGame.Framework/Utilities/Imaging/ImageReader.cs
new file mode 100644
index 00000000000..15d390c28ea
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Imaging/ImageReader.cs
@@ -0,0 +1,59 @@
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace MonoGame.Utilities
+{
+    internal static unsafe class ImageReader
+    {
+        public static byte[] Read(Stream stream, out int x, out int y, out int comp, int req_comp)
+        {
+            byte[] bytes, data = null;
+
+            // Rewind stream if it is at end
+            if (stream.CanSeek && stream.Length == stream.Position)
+            {
+                stream.Seek(0, SeekOrigin.Begin);
+            }
+
+            using (var ms = new MemoryStream())
+            {
+                stream.CopyTo(ms);
+                bytes = ms.ToArray();
+            }
+
+            int xx, yy, ccomp;
+            byte* result = null;
+            try
+            {
+                fixed (byte* b = bytes)
+                {
+                    result = Imaging.stbi_load_from_memory(b, bytes.Length, &xx, &yy, &ccomp, req_comp);
+                }
+
+                x = xx;
+                y = yy;
+                comp = ccomp;
+
+                if (result == null)
+                {
+                    throw new InvalidOperationException(Imaging.LastError);
+                }
+
+                // Convert to array
+                var c = req_comp != 0 ? req_comp : comp;
+                data = new byte[x * y * c];
+                Marshal.Copy(new IntPtr(result), data, 0, data.Length);
+            }
+            finally
+            {
+                if (result != null)
+                {
+                    Operations.Free(result);
+                }
+            }
+
+            return data;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/Imaging/ImageWriter.cs b/MonoGame.Framework/Utilities/Imaging/ImageWriter.cs
new file mode 100644
index 00000000000..3cdbe704367
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Imaging/ImageWriter.cs
@@ -0,0 +1,74 @@
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace MonoGame.Utilities
+{
+    internal enum ImageWriterFormat
+    {
+        Bmp,
+        Tga,
+        Png,
+        Jpg,
+    }
+
+    internal unsafe class ImageWriter
+    {
+        private Stream _stream;
+        private byte[] _buffer = new byte[1024];
+
+        private int WriteCallback(void* context, void* data, int size)
+        {
+            if (data == null || size <= 0)
+            {
+                return 0;
+            }
+
+            if (_buffer.Length < size)
+            {
+                _buffer = new byte[size*2];
+            }
+
+            var bptr = (byte*) data;
+
+            Marshal.Copy(new IntPtr(bptr), _buffer, 0, size);
+
+            _stream.Write(_buffer, 0, size);
+
+            return size;
+        }
+
+        public void Write(byte[] bytes, int x, int y, int comp, ImageWriterFormat format, Stream dest)
+        {
+            try
+            {
+                _stream = dest;
+                fixed (byte* b = &bytes[0])
+                {
+                    switch (format)
+                    {
+                        case ImageWriterFormat.Bmp:
+                            Imaging.stbi_write_bmp_to_func(WriteCallback, null, x, y, comp, b);
+                            break;
+                        case ImageWriterFormat.Tga:
+                            Imaging.stbi_write_tga_to_func(WriteCallback, null, x, y, comp, b);
+                            break;
+                        case ImageWriterFormat.Jpg:
+                            Imaging.stbi_write_jpg_to_func(WriteCallback, null, x, y, comp, b, 90);
+                            break;
+
+                        case ImageWriterFormat.Png:
+                            Imaging.stbi_write_png_to_func(WriteCallback, null, x, y, comp, b, x*comp);
+                            break;
+                        default:
+                            throw new ArgumentOutOfRangeException("format", format, null);
+                    }
+                }
+            }
+            finally
+            {
+                _stream = null;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Imaging/Operations.cs b/MonoGame.Framework/Utilities/Imaging/Operations.cs
new file mode 100644
index 00000000000..1734b7833d6
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Imaging/Operations.cs
@@ -0,0 +1,94 @@
+using System.Collections.Concurrent;
+
+namespace MonoGame.Utilities
+{
+    internal static unsafe class Operations
+    {
+        internal static ConcurrentDictionary<long, Pointer> _pointers = new ConcurrentDictionary<long, Pointer>();
+
+        public static long AllocatedTotal
+        {
+            get { return Pointer.AllocatedTotal; }
+        }
+
+        public static void* Malloc(long size)
+        {
+            var result = new PinnedArray<byte>(size);
+            _pointers[(long) result.Ptr] = result;
+
+            return result.Ptr;
+        }
+
+        public static void Memcpy(void* a, void* b, long size)
+        {
+            var ap = (byte*) a;
+            var bp = (byte*) b;
+            for (long i = 0; i < size; ++i)
+            {
+                *ap++ = *bp++;
+            }
+        }
+
+        public static void MemMove(void* a, void* b, long size)
+        {
+            using (var temp = new PinnedArray<byte>(size))
+            {
+                Memcpy(temp.Ptr, b, size);
+                Memcpy(a, temp.Ptr, size);
+            }
+        }
+
+        public static void Free(void* a)
+        {
+            Pointer pointer;
+            if (!_pointers.TryRemove((long) a, out pointer))
+            {
+                return;
+            }
+
+            pointer.Dispose();
+        }
+
+        public static void* Realloc(void* a, long newSize)
+        {
+            Pointer pointer;
+            if (!_pointers.TryGetValue((long) a, out pointer))
+            {
+                // Allocate new
+                return Malloc(newSize);
+            }
+
+            if (newSize <= pointer.Size)
+            {
+                // Realloc not required
+                return a;
+            }
+
+            var result = Malloc(newSize);
+            Memcpy(result, a, pointer.Size);
+
+            _pointers.TryRemove((long) pointer.Ptr, out pointer);
+            pointer.Dispose();
+
+            return result;
+        }
+
+        public static int Memcmp(void* a, void* b, long size)
+        {
+            var result = 0;
+            var ap = (byte*) a;
+            var bp = (byte*) b;
+            for (long i = 0; i < size; ++i)
+            {
+                if (*ap != *bp)
+                {
+                    result += 1;
+                }
+                ap++;
+                bp++;
+            }
+
+            return result;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Imaging/PinnedArray.cs b/MonoGame.Framework/Utilities/Imaging/PinnedArray.cs
new file mode 100644
index 00000000000..c90c7eea58a
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Imaging/PinnedArray.cs
@@ -0,0 +1,143 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace MonoGame.Utilities
+{
+    internal abstract unsafe class Pointer : IDisposable
+    {
+        protected static long _allocatedTotal;
+        protected static object _lock = new object();
+
+        public abstract long Size { get; }
+        public abstract void* Ptr { get; }
+
+        public static long AllocatedTotal
+        {
+            get { return _allocatedTotal; }
+        }
+
+        public abstract void Dispose();
+
+        public static implicit operator void*(Pointer ptr)
+        {
+            return ptr.Ptr;
+        }
+
+        public static implicit operator byte*(Pointer ptr)
+        {
+            return (byte*) ptr.Ptr;
+        }
+
+        public static implicit operator short*(Pointer ptr)
+        {
+            return (short*) ptr.Ptr;
+        }
+    }
+
+    internal unsafe class PinnedArray<T> : Pointer
+    {
+        private GCHandle _handle;
+        private bool _disposed;
+        private void* _ptr;
+        private long _size;
+
+        public GCHandle Handle
+        {
+            get { return _handle; }
+        }
+
+        public override void* Ptr
+        {
+            get { return _ptr; }
+        }
+
+        public T[] Data { get; private set; }
+
+        public T this[long index]
+        {
+            get { return Data[index]; }
+            set { Data[index] = value; }
+        }
+
+        public long Count { get; private set; }
+
+        public override long Size
+        {
+            get { return _size; }
+        }
+
+        public long ElementSize { get; private set; }
+
+        public PinnedArray(long size)
+            : this(new T[size])
+        {
+        }
+
+        public PinnedArray(T[] data)
+        {
+            Data = data;
+
+            _ptr = null;
+            if (data != null)
+            {
+                _handle = GCHandle.Alloc(data, GCHandleType.Pinned);
+                var addr = _handle.AddrOfPinnedObject();
+                _ptr = addr.ToPointer();
+                ElementSize = Marshal.SizeOf(typeof (T));
+                Count = data.Length;
+                _size = ElementSize*data.Length;
+            }
+            else
+            {
+                ElementSize = 0;
+                Count = 0;
+                _size = 0;
+            }
+
+            lock (_lock)
+            {
+                _allocatedTotal += _size;
+            }
+        }
+
+        ~PinnedArray()
+        {
+            Dispose(false);
+        }
+
+        public override void Dispose()
+        {
+            Dispose(true);
+
+            // This object will be cleaned up by the Dispose method.
+            // Therefore, you should call GC.SupressFinalize to
+            // take this object off the finalization queue
+            // and prevent finalization code for this object
+            // from executing a second time.
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            lock (_lock)
+            {
+                _allocatedTotal -= Size;
+            }
+
+            if (Data != null)
+            {
+                _handle.Free();
+                _ptr = null;
+                Data = null;
+                _size = 0;
+            }
+
+            _disposed = true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Imaging/Stb.Image.Generated.cs b/MonoGame.Framework/Utilities/Imaging/Stb.Image.Generated.cs
new file mode 100644
index 00000000000..126855a2bdc
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Imaging/Stb.Image.Generated.cs
@@ -0,0 +1,4790 @@
+// Generated by Sichem at 1/6/2018 7:16:35 PM
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace MonoGame.Utilities
+{
+    unsafe partial class Imaging
+    {
+        public class stbi__context
+        {
+            public uint img_x;
+            public uint img_y;
+            public int img_n;
+            public int img_out_n;
+            public stbi_io_callbacks io = new stbi_io_callbacks();
+            public void* io_user_data;
+            public int read_from_callbacks;
+            public int buflen;
+            public PinnedArray<byte> buffer_start = new PinnedArray<byte>(128);
+            public byte* img_buffer;
+            public byte* img_buffer_end;
+            public byte* img_buffer_original;
+            public byte* img_buffer_original_end;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct stbi__result_info
+        {
+            public int bits_per_channel;
+            public int num_channels;
+            public int channel_order;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct stbi__huffman
+        {
+            public fixed byte fast [1 << 9];
+            public fixed ushort code [256];
+            public fixed byte values [256];
+            public fixed byte size [257];
+            public fixed uint maxcode [18];
+            public fixed int delta [17];
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct stbi__zhuffman
+        {
+            public fixed ushort fast [1 << 9];
+            public fixed ushort firstcode [16];
+            public fixed int maxcode [17];
+            public fixed ushort firstsymbol [16];
+            public fixed byte size [288];
+            public fixed ushort value [288];
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct stbi__zbuf
+        {
+            public byte* zbuffer;
+            public byte* zbuffer_end;
+            public int num_bits;
+            public uint code_buffer;
+            public sbyte* zout;
+            public sbyte* zout_start;
+            public sbyte* zout_end;
+            public int z_expandable;
+            public stbi__zhuffman z_length;
+            public stbi__zhuffman z_distance;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct stbi__pngchunk
+        {
+            public uint length;
+            public uint type;
+        }
+
+        public class stbi__png
+        {
+            public stbi__context s = new stbi__context();
+            public byte* idata;
+            public byte* expanded;
+            public byte* _out_;
+            public int depth;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct stbi__bmp_data
+        {
+            public int bpp;
+            public int offset;
+            public int hsz;
+            public uint mr;
+            public uint mg;
+            public uint mb;
+            public uint ma;
+            public uint all_a;
+        }
+
+        public const int STBI_default = 0;
+        public const int STBI_grey = 1;
+        public const int STBI_grey_alpha = 2;
+        public const int STBI_rgb = 3;
+        public const int STBI_rgb_alpha = 4;
+        public const int STBI_ORDER_RGB = 0;
+        public const int STBI_ORDER_BGR = 1;
+        public const int STBI__SCAN_load = 0;
+        public const int STBI__SCAN_type = 1;
+        public const int STBI__SCAN_header = 2;
+        public const int STBI__F_none = 0;
+        public const int STBI__F_sub = 1;
+        public const int STBI__F_up = 2;
+        public const int STBI__F_avg = 3;
+        public const int STBI__F_paeth = 4;
+        public const int STBI__F_avg_first = 5;
+        public const int STBI__F_paeth_first = 6;
+        public static float stbi__h2l_gamma_i = (float) (1.0f/2.2f);
+        public static float stbi__h2l_scale_i = (float) (1.0f);
+
+        public static uint[] stbi__bmask =
+        {
+            0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535
+        };
+
+        public static int[] stbi__jbias =
+        {
+            0, -1, -3, -7, -15, -31, -63, -127, -255, -511, -1023, -2047, -4095, -8191, -16383,
+            -32767
+        };
+
+        public static byte[] stbi__jpeg_dezigzag =
+        {
+            0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40,
+            48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58,
+            59, 52,
+            45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
+            63
+        };
+
+        public static int[] stbi__zlength_base =
+        {
+            3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67,
+            83, 99, 115, 131, 163, 195, 227, 258, 0, 0
+        };
+
+        public static int[] stbi__zlength_extra =
+        {
+            0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5,
+            5, 5, 5, 0, 0, 0
+        };
+
+        public static int[] stbi__zdist_base =
+        {
+            1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769,
+            1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0
+        };
+
+        public static int[] stbi__zdist_extra =
+        {
+            0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11,
+            11, 12, 12, 13, 13
+        };
+
+        public static byte[] length_dezigzag = {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+        public static byte[] stbi__zdefault_length =
+        {
+            8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+            8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+            8, 8, 8,
+            8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+            8, 8, 8,
+            8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+            8, 8, 8,
+            8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+            9, 9, 9,
+            9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+            9, 9, 9,
+            9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+            9, 7, 7,
+            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8
+        };
+
+        public static byte[] stbi__zdefault_distance =
+        {
+            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+            5, 5, 5, 5, 5, 5, 5, 5
+        };
+
+        public static byte[] png_sig = {137, 80, 78, 71, 13, 10, 26, 10};
+
+        public static byte[] first_row_filter =
+        {
+            STBI__F_none, STBI__F_sub, STBI__F_none, STBI__F_avg_first,
+            STBI__F_paeth_first
+        };
+
+        public static byte[] stbi__depth_scale_table = {0, 0xff, 0x55, 0, 0x11, 0, 0, 0, 0x01};
+        public static int stbi__unpremultiply_on_load = (int) (0);
+        public static int stbi__de_iphone_flag = (int) (0);
+
+        public static void stbi__start_mem(stbi__context s, byte* buffer, int len)
+        {
+            s.io.read = (null);
+            s.read_from_callbacks = (int) (0);
+            s.img_buffer = s.img_buffer_original = buffer;
+            s.img_buffer_end = s.img_buffer_original_end = buffer + len;
+        }
+
+        public static void stbi__start_callbacks(stbi__context s, stbi_io_callbacks c, void* user)
+        {
+            s.io = (stbi_io_callbacks) (c);
+            s.io_user_data = user;
+            s.buflen = (int) (s.buffer_start.Size);
+            s.read_from_callbacks = (int) (1);
+            s.img_buffer_original = s.buffer_start;
+            stbi__refill_buffer(s);
+            s.img_buffer_original_end = s.img_buffer_end;
+        }
+
+        public static void stbi__rewind(stbi__context s)
+        {
+            s.img_buffer = s.img_buffer_original;
+            s.img_buffer_end = s.img_buffer_original_end;
+        }
+
+        public static int stbi__addsizes_valid(int a, int b)
+        {
+            if ((b) < (0)) return (int) (0);
+            return (a <= 2147483647 - b) ? 1 : 0;
+        }
+
+        public static int stbi__mul2sizes_valid(int a, int b)
+        {
+            if (((a) < (0)) || ((b) < (0))) return (int) (0);
+            if ((b) == (0)) return (int) (1);
+            return (a <= 2147483647/b) ? 1 : 0;
+        }
+
+        public static int stbi__mad2sizes_valid(int a, int b, int add)
+        {
+            return
+                (int)
+                    (((stbi__mul2sizes_valid((int) (a), (int) (b))) != 0) &&
+                     ((stbi__addsizes_valid((int) (a*b), (int) (add))) != 0)
+                        ? 1
+                        : 0);
+        }
+
+        public static int stbi__mad3sizes_valid(int a, int b, int c, int add)
+        {
+            return
+                (int)
+                    ((((stbi__mul2sizes_valid((int) (a), (int) (b))) != 0) &&
+                      ((stbi__mul2sizes_valid((int) (a*b), (int) (c))) != 0)) &&
+                     ((stbi__addsizes_valid((int) (a*b*c), (int) (add))) != 0)
+                        ? 1
+                        : 0);
+        }
+
+        public static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add)
+        {
+            return
+                (int)
+                    (((((stbi__mul2sizes_valid((int) (a), (int) (b))) != 0) &&
+                       ((stbi__mul2sizes_valid((int) (a*b), (int) (c))) != 0)) &&
+                      ((stbi__mul2sizes_valid((int) (a*b*c), (int) (d))) != 0)) &&
+                     ((stbi__addsizes_valid((int) (a*b*c*d), (int) (add))) != 0)
+                        ? 1
+                        : 0);
+        }
+
+        public static void* stbi__malloc_mad2(int a, int b, int add)
+        {
+            if (stbi__mad2sizes_valid((int) (a), (int) (b), (int) (add)) == 0) return (null);
+            return stbi__malloc((ulong) (a*b + add));
+        }
+
+        public static void* stbi__malloc_mad3(int a, int b, int c, int add)
+        {
+            if (stbi__mad3sizes_valid((int) (a), (int) (b), (int) (c), (int) (add)) == 0) return (null);
+            return stbi__malloc((ulong) (a*b*c + add));
+        }
+
+        public static void* stbi__malloc_mad4(int a, int b, int c, int d, int add)
+        {
+            if (stbi__mad4sizes_valid((int) (a), (int) (b), (int) (c), (int) (d), (int) (add)) == 0) return (null);
+            return stbi__malloc((ulong) (a*b*c*d + add));
+        }
+
+        public static void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
+        {
+            stbi__vertically_flip_on_load = (int) (flag_true_if_should_flip);
+        }
+
+        public static void* stbi__load_main(stbi__context s, int* x, int* y, int* comp, int req_comp,
+            stbi__result_info* ri,
+            int bpc)
+        {
+            ri->bits_per_channel = (int) (8);
+            ri->channel_order = (int) (STBI_ORDER_RGB);
+            ri->num_channels = (int) (0);
+            if ((stbi__jpeg_test(s)) != 0) return stbi__jpeg_load(s, x, y, comp, (int) (req_comp), ri);
+            if ((stbi__png_test(s)) != 0) return stbi__png_load(s, x, y, comp, (int) (req_comp), ri);
+            if ((stbi__bmp_test(s)) != 0) return stbi__bmp_load(s, x, y, comp, (int) (req_comp), ri);
+            if ((stbi__gif_test(s)) != 0) return stbi__gif_load(s, x, y, comp, (int) (req_comp), ri);
+            if ((stbi__tga_test(s)) != 0) return stbi__tga_load(s, x, y, comp, (int) (req_comp), ri);
+            return ((byte*) ((ulong) ((stbi__err("unknown image type")) != 0 ? ((byte*) null) : (null))));
+        }
+
+        public static byte* stbi__convert_16_to_8(ushort* orig, int w, int h, int channels)
+        {
+            int i;
+            int img_len = (int) (w*h*channels);
+            byte* reduced;
+            reduced = (byte*) (stbi__malloc((ulong) (img_len)));
+            if ((reduced) == (null))
+                return ((byte*) ((ulong) ((stbi__err("outofmem")) != 0 ? ((byte*) null) : (null))));
+            for (i = (int) (0); (i) < (img_len); ++i)
+            {
+                reduced[i] = ((byte) ((orig[i] >> 8) & 0xFF));
+            }
+            free(orig);
+            return reduced;
+        }
+
+        public static ushort* stbi__convert_8_to_16(byte* orig, int w, int h, int channels)
+        {
+            int i;
+            int img_len = (int) (w*h*channels);
+            ushort* enlarged;
+            enlarged = (ushort*) (stbi__malloc((ulong) (img_len*2)));
+            if ((enlarged) == (null))
+                return (ushort*) ((byte*) ((ulong) ((stbi__err("outofmem")) != 0 ? ((byte*) null) : (null))));
+            for (i = (int) (0); (i) < (img_len); ++i)
+            {
+                enlarged[i] = ((ushort) ((orig[i] << 8) + orig[i]));
+            }
+            free(orig);
+            return enlarged;
+        }
+
+        public static void stbi__vertical_flip(void* image, int w, int h, int bytes_per_pixel)
+        {
+            int row;
+            ulong bytes_per_row = (ulong) (w*bytes_per_pixel);
+            byte* temp = stackalloc byte[2048];
+            byte* bytes = (byte*) (image);
+            for (row = (int) (0); (row) < (h >> 1); row++)
+            {
+                byte* row0 = bytes + (ulong) row*bytes_per_row;
+                byte* row1 = bytes + (ulong) (h - row - 1)*bytes_per_row;
+                ulong bytes_left = (ulong) (bytes_per_row);
+                while ((bytes_left) != 0)
+                {
+                    ulong bytes_copy = (ulong) (((bytes_left) < (2048)) ? bytes_left : 2048);
+                    memcpy(temp, row0, (ulong) (bytes_copy));
+                    memcpy(row0, row1, (ulong) (bytes_copy));
+                    memcpy(row1, temp, (ulong) (bytes_copy));
+                    row0 += bytes_copy;
+                    row1 += bytes_copy;
+                    bytes_left -= (ulong) (bytes_copy);
+                }
+            }
+        }
+
+        public static byte* stbi__load_and_postprocess_8bit(stbi__context s, int* x, int* y, int* comp, int req_comp)
+        {
+            stbi__result_info ri = new stbi__result_info();
+            void* result = stbi__load_main(s, x, y, comp, (int) (req_comp), &ri, (int) (8));
+            if ((result) == (null)) return (null);
+            if (ri.bits_per_channel != 8)
+            {
+                result = stbi__convert_16_to_8((ushort*) (result), (int) (*x), (int) (*y),
+                    (int) ((req_comp) == (0) ? *comp : req_comp));
+                ri.bits_per_channel = (int) (8);
+            }
+
+            if ((stbi__vertically_flip_on_load) != 0)
+            {
+                int channels = (int) ((req_comp) != 0 ? req_comp : *comp);
+                stbi__vertical_flip(result, (int) (*x), (int) (*y), (int) (channels));
+            }
+
+            return (byte*) (result);
+        }
+
+        public static ushort* stbi__load_and_postprocess_16bit(stbi__context s, int* x, int* y, int* comp, int req_comp)
+        {
+            stbi__result_info ri = new stbi__result_info();
+            void* result = stbi__load_main(s, x, y, comp, (int) (req_comp), &ri, (int) (16));
+            if ((result) == (null)) return (null);
+            if (ri.bits_per_channel != 16)
+            {
+                result = stbi__convert_8_to_16((byte*) (result), (int) (*x), (int) (*y),
+                    (int) ((req_comp) == (0) ? *comp : req_comp));
+                ri.bits_per_channel = (int) (16);
+            }
+
+            if ((stbi__vertically_flip_on_load) != 0)
+            {
+                int channels = (int) ((req_comp) != 0 ? req_comp : *comp);
+                stbi__vertical_flip(result, (int) (*x), (int) (*y), (int) (channels*2));
+            }
+
+            return (ushort*) (result);
+        }
+
+        public static ushort* stbi_load_16_from_memory(byte* buffer, int len, int* x, int* y, int* channels_in_file,
+            int desired_channels)
+        {
+            stbi__context s = new stbi__context();
+            stbi__start_mem(s, buffer, (int) (len));
+            return stbi__load_and_postprocess_16bit(s, x, y, channels_in_file, (int) (desired_channels));
+        }
+
+        public static ushort* stbi_load_16_from_callbacks(stbi_io_callbacks clbk, void* user, int* x, int* y,
+            int* channels_in_file, int desired_channels)
+        {
+            stbi__context s = new stbi__context();
+            stbi__start_callbacks(s, clbk, user);
+            return stbi__load_and_postprocess_16bit(s, x, y, channels_in_file, (int) (desired_channels));
+        }
+
+        public static byte* stbi_load_from_memory(byte* buffer, int len, int* x, int* y, int* comp, int req_comp)
+        {
+            stbi__context s = new stbi__context();
+            stbi__start_mem(s, buffer, (int) (len));
+            return stbi__load_and_postprocess_8bit(s, x, y, comp, (int) (req_comp));
+        }
+
+        public static byte* stbi_load_from_callbacks(stbi_io_callbacks clbk, void* user, int* x, int* y, int* comp,
+            int req_comp)
+        {
+            stbi__context s = new stbi__context();
+            stbi__start_callbacks(s, clbk, user);
+            return stbi__load_and_postprocess_8bit(s, x, y, comp, (int) (req_comp));
+        }
+
+        public static void stbi_hdr_to_ldr_gamma(float gamma)
+        {
+            stbi__h2l_gamma_i = (float) (1/gamma);
+        }
+
+        public static void stbi_hdr_to_ldr_scale(float scale)
+        {
+            stbi__h2l_scale_i = (float) (1/scale);
+        }
+
+        public static void stbi__refill_buffer(stbi__context s)
+        {
+            int n = (int) (s.io.read(s.io_user_data, (sbyte*) (s.buffer_start), (int) (s.buflen)));
+            if ((n) == (0))
+            {
+                s.read_from_callbacks = (int) (0);
+                s.img_buffer = s.buffer_start;
+                s.img_buffer_end = s.buffer_start;
+                s.img_buffer_end++;
+                *s.img_buffer = (byte) (0);
+            }
+            else
+            {
+                s.img_buffer = s.buffer_start;
+                s.img_buffer_end = s.buffer_start;
+                s.img_buffer_end += n;
+            }
+
+        }
+
+        public static byte stbi__get8(stbi__context s)
+        {
+            if ((s.img_buffer) < (s.img_buffer_end)) return (byte) (*s.img_buffer++);
+            if ((s.read_from_callbacks) != 0)
+            {
+                stbi__refill_buffer(s);
+                return (byte) (*s.img_buffer++);
+            }
+
+            return (byte) (0);
+        }
+
+        public static int stbi__at_eof(stbi__context s)
+        {
+            if ((s.io.read) != null)
+            {
+                if (s.io.eof(s.io_user_data) == 0) return (int) (0);
+                if ((s.read_from_callbacks) == (0)) return (int) (1);
+            }
+
+            return (int) ((s.img_buffer) >= (s.img_buffer_end) ? 1 : 0);
+        }
+
+        public static void stbi__skip(stbi__context s, int n)
+        {
+            if ((n) < (0))
+            {
+                s.img_buffer = s.img_buffer_end;
+                return;
+            }
+
+            if ((s.io.read) != null)
+            {
+                int blen = (int) (s.img_buffer_end - s.img_buffer);
+                if ((blen) < (n))
+                {
+                    s.img_buffer = s.img_buffer_end;
+                    s.io.skip(s.io_user_data, (int) (n - blen));
+                    return;
+                }
+            }
+
+            s.img_buffer += n;
+        }
+
+        public static int stbi__getn(stbi__context s, byte* buffer, int n)
+        {
+            if ((s.io.read) != null)
+            {
+                int blen = (int) (s.img_buffer_end - s.img_buffer);
+                if ((blen) < (n))
+                {
+                    int res;
+                    int count;
+                    memcpy(buffer, s.img_buffer, (ulong) (blen));
+                    count = (int) (s.io.read(s.io_user_data, (sbyte*) (buffer) + blen, (int) (n - blen)));
+                    res = (int) ((count) == (n - blen) ? 1 : 0);
+                    s.img_buffer = s.img_buffer_end;
+                    return (int) (res);
+                }
+            }
+
+            if (s.img_buffer + n <= s.img_buffer_end)
+            {
+                memcpy(buffer, s.img_buffer, (ulong) (n));
+                s.img_buffer += n;
+                return (int) (1);
+            }
+            else return (int) (0);
+        }
+
+        public static int stbi__get16be(stbi__context s)
+        {
+            int z = (int) (stbi__get8(s));
+            return (int) ((z << 8) + stbi__get8(s));
+        }
+
+        public static uint stbi__get32be(stbi__context s)
+        {
+            uint z = (uint) (stbi__get16be(s));
+            return (uint) ((z << 16) + stbi__get16be(s));
+        }
+
+        public static int stbi__get16le(stbi__context s)
+        {
+            int z = (int) (stbi__get8(s));
+            return (int) (z + (stbi__get8(s) << 8));
+        }
+
+        public static uint stbi__get32le(stbi__context s)
+        {
+            uint z = (uint) (stbi__get16le(s));
+            return (uint) (z + (stbi__get16le(s) << 16));
+        }
+
+        public static byte stbi__compute_y(int r, int g, int b)
+        {
+            return (byte) (((r*77) + (g*150) + (29*b)) >> 8);
+        }
+
+        public static byte* stbi__convert_format(byte* data, int img_n, int req_comp, uint x, uint y)
+        {
+            int i;
+            int j;
+            byte* good;
+            if ((req_comp) == (img_n)) return data;
+            good = (byte*) (stbi__malloc_mad3((int) (req_comp), (int) (x), (int) (y), (int) (0)));
+            if ((good) == (null))
+            {
+                free(data);
+                return ((byte*) ((ulong) ((stbi__err("outofmem")) != 0 ? ((byte*) null) : (null))));
+            }
+
+            for (j = (int) (0); (j) < ((int) (y)); ++j)
+            {
+                byte* src = data + j*x*img_n;
+                byte* dest = good + j*x*req_comp;
+                switch (((img_n)*8 + (req_comp)))
+                {
+                    case ((1)*8 + (2)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 1 , dest += 2)
+                        {
+                            dest[0] = (byte) (src[0]);
+                            dest[1] = (byte) (255);
+                        }
+                        break;
+                    case ((1)*8 + (3)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 1 , dest += 3)
+                        {
+                            dest[0] = (byte) (dest[1] = (byte) (dest[2] = (byte) (src[0])));
+                        }
+                        break;
+                    case ((1)*8 + (4)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 1 , dest += 4)
+                        {
+                            dest[0] = (byte) (dest[1] = (byte) (dest[2] = (byte) (src[0])));
+                            dest[3] = (byte) (255);
+                        }
+                        break;
+                    case ((2)*8 + (1)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 2 , dest += 1)
+                        {
+                            dest[0] = (byte) (src[0]);
+                        }
+                        break;
+                    case ((2)*8 + (3)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 2 , dest += 3)
+                        {
+                            dest[0] = (byte) (dest[1] = (byte) (dest[2] = (byte) (src[0])));
+                        }
+                        break;
+                    case ((2)*8 + (4)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 2 , dest += 4)
+                        {
+                            dest[0] = (byte) (dest[1] = (byte) (dest[2] = (byte) (src[0])));
+                            dest[3] = (byte) (src[1]);
+                        }
+                        break;
+                    case ((3)*8 + (4)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 3 , dest += 4)
+                        {
+                            dest[0] = (byte) (src[0]);
+                            dest[1] = (byte) (src[1]);
+                            dest[2] = (byte) (src[2]);
+                            dest[3] = (byte) (255);
+                        }
+                        break;
+                    case ((3)*8 + (1)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 3 , dest += 1)
+                        {
+                            dest[0] = (byte) (stbi__compute_y((int) (src[0]), (int) (src[1]), (int) (src[2])));
+                        }
+                        break;
+                    case ((3)*8 + (2)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 3 , dest += 2)
+                        {
+                            dest[0] = (byte) (stbi__compute_y((int) (src[0]), (int) (src[1]), (int) (src[2])));
+                            dest[1] = (byte) (255);
+                        }
+                        break;
+                    case ((4)*8 + (1)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 4 , dest += 1)
+                        {
+                            dest[0] = (byte) (stbi__compute_y((int) (src[0]), (int) (src[1]), (int) (src[2])));
+                        }
+                        break;
+                    case ((4)*8 + (2)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 4 , dest += 2)
+                        {
+                            dest[0] = (byte) (stbi__compute_y((int) (src[0]), (int) (src[1]), (int) (src[2])));
+                            dest[1] = (byte) (src[3]);
+                        }
+                        break;
+                    case ((4)*8 + (3)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 4 , dest += 3)
+                        {
+                            dest[0] = (byte) (src[0]);
+                            dest[1] = (byte) (src[1]);
+                            dest[2] = (byte) (src[2]);
+                        }
+                        break;
+                    default:
+                        return ((byte*) ((ulong) ((stbi__err("0")) != 0 ? ((byte*) null) : (null))));
+                }
+            }
+            free(data);
+            return good;
+        }
+
+        public static ushort stbi__compute_y_16(int r, int g, int b)
+        {
+            return (ushort) (((r*77) + (g*150) + (29*b)) >> 8);
+        }
+
+        public static ushort* stbi__convert_format16(ushort* data, int img_n, int req_comp, uint x, uint y)
+        {
+            int i;
+            int j;
+            ushort* good;
+            if ((req_comp) == (img_n)) return data;
+            good = (ushort*) (stbi__malloc((ulong) (req_comp*x*y*2)));
+            if ((good) == (null))
+            {
+                free(data);
+                return (ushort*) ((byte*) ((ulong) ((stbi__err("outofmem")) != 0 ? ((byte*) null) : (null))));
+            }
+
+            for (j = (int) (0); (j) < ((int) (y)); ++j)
+            {
+                ushort* src = data + j*x*img_n;
+                ushort* dest = good + j*x*req_comp;
+                switch (((img_n)*8 + (req_comp)))
+                {
+                    case ((1)*8 + (2)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 1 , dest += 2)
+                        {
+                            dest[0] = (ushort) (src[0]);
+                            dest[1] = (ushort) (0xffff);
+                        }
+                        break;
+                    case ((1)*8 + (3)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 1 , dest += 3)
+                        {
+                            dest[0] = (ushort) (dest[1] = (ushort) (dest[2] = (ushort) (src[0])));
+                        }
+                        break;
+                    case ((1)*8 + (4)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 1 , dest += 4)
+                        {
+                            dest[0] = (ushort) (dest[1] = (ushort) (dest[2] = (ushort) (src[0])));
+                            dest[3] = (ushort) (0xffff);
+                        }
+                        break;
+                    case ((2)*8 + (1)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 2 , dest += 1)
+                        {
+                            dest[0] = (ushort) (src[0]);
+                        }
+                        break;
+                    case ((2)*8 + (3)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 2 , dest += 3)
+                        {
+                            dest[0] = (ushort) (dest[1] = (ushort) (dest[2] = (ushort) (src[0])));
+                        }
+                        break;
+                    case ((2)*8 + (4)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 2 , dest += 4)
+                        {
+                            dest[0] = (ushort) (dest[1] = (ushort) (dest[2] = (ushort) (src[0])));
+                            dest[3] = (ushort) (src[1]);
+                        }
+                        break;
+                    case ((3)*8 + (4)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 3 , dest += 4)
+                        {
+                            dest[0] = (ushort) (src[0]);
+                            dest[1] = (ushort) (src[1]);
+                            dest[2] = (ushort) (src[2]);
+                            dest[3] = (ushort) (0xffff);
+                        }
+                        break;
+                    case ((3)*8 + (1)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 3 , dest += 1)
+                        {
+                            dest[0] = (ushort) (stbi__compute_y_16((int) (src[0]), (int) (src[1]), (int) (src[2])));
+                        }
+                        break;
+                    case ((3)*8 + (2)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 3 , dest += 2)
+                        {
+                            dest[0] = (ushort) (stbi__compute_y_16((int) (src[0]), (int) (src[1]), (int) (src[2])));
+                            dest[1] = (ushort) (0xffff);
+                        }
+                        break;
+                    case ((4)*8 + (1)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 4 , dest += 1)
+                        {
+                            dest[0] = (ushort) (stbi__compute_y_16((int) (src[0]), (int) (src[1]), (int) (src[2])));
+                        }
+                        break;
+                    case ((4)*8 + (2)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 4 , dest += 2)
+                        {
+                            dest[0] = (ushort) (stbi__compute_y_16((int) (src[0]), (int) (src[1]), (int) (src[2])));
+                            dest[1] = (ushort) (src[3]);
+                        }
+                        break;
+                    case ((4)*8 + (3)):
+                        for (i = (int) (x - 1); (i) >= (0); --i , src += 4 , dest += 3)
+                        {
+                            dest[0] = (ushort) (src[0]);
+                            dest[1] = (ushort) (src[1]);
+                            dest[2] = (ushort) (src[2]);
+                        }
+                        break;
+                    default:
+                        return (ushort*) ((byte*) ((ulong) ((stbi__err("0")) != 0 ? ((byte*) null) : (null))));
+                }
+            }
+            free(data);
+            return good;
+        }
+
+        public static int stbi__build_huffman(stbi__huffman* h, int* count)
+        {
+            int i;
+            int j;
+            int k = (int) (0);
+            int code;
+            for (i = (int) (0); (i) < (16); ++i)
+            {
+                for (j = (int) (0); (j) < (count[i]); ++j)
+                {
+                    h->size[k++] = ((byte) (i + 1));
+                }
+            }
+            h->size[k] = (byte) (0);
+            code = (int) (0);
+            k = (int) (0);
+            for (j = (int) (1); j <= 16; ++j)
+            {
+                h->delta[j] = (int) (k - code);
+                if ((h->size[k]) == (j))
+                {
+                    while ((h->size[k]) == (j))
+                    {
+                        h->code[k++] = ((ushort) (code++));
+                    }
+                    if ((code - 1) >= (1 << j)) return (int) (stbi__err("bad code lengths"));
+                }
+                h->maxcode[j] = (uint) (code << (16 - j));
+                code <<= 1;
+            }
+            h->maxcode[j] = (uint) (0xffffffff);
+            memset(h->fast, (int) (255), (ulong) (1 << 9));
+            for (i = (int) (0); (i) < (k); ++i)
+            {
+                int s = (int) (h->size[i]);
+                if (s <= 9)
+                {
+                    int c = (int) (h->code[i] << (9 - s));
+                    int m = (int) (1 << (9 - s));
+                    for (j = (int) (0); (j) < (m); ++j)
+                    {
+                        h->fast[c + j] = ((byte) (i));
+                    }
+                }
+            }
+            return (int) (1);
+        }
+
+        public static void stbi__build_fast_ac(short* fast_ac, stbi__huffman* h)
+        {
+            int i;
+            for (i = (int) (0); (i) < (1 << 9); ++i)
+            {
+                byte fast = (byte) (h->fast[i]);
+                fast_ac[i] = (short) (0);
+                if ((fast) < (255))
+                {
+                    int rs = (int) (h->values[fast]);
+                    int run = (int) ((rs >> 4) & 15);
+                    int magbits = (int) (rs & 15);
+                    int len = (int) (h->size[fast]);
+                    if (((magbits) != 0) && (len + magbits <= 9))
+                    {
+                        int k = (int) (((i << len) & ((1 << 9) - 1)) >> (9 - magbits));
+                        int m = (int) (1 << (magbits - 1));
+                        if ((k) < (m)) k += (int) ((~0U << magbits) + 1);
+                        if (((k) >= (-128)) && (k <= 127))
+                            fast_ac[i] = ((short) ((k << 8) + (run << 4) + (len + magbits)));
+                    }
+                }
+            }
+        }
+
+        public static void stbi__grow_buffer_unsafe(stbi__jpeg j)
+        {
+            do
+            {
+                int b = (int) ((j.nomore) != 0 ? 0 : stbi__get8(j.s));
+                if ((b) == (0xff))
+                {
+                    int c = (int) (stbi__get8(j.s));
+                    while ((c) == (0xff))
+                    {
+                        c = (int) (stbi__get8(j.s));
+                    }
+                    if (c != 0)
+                    {
+                        j.marker = ((byte) (c));
+                        j.nomore = (int) (1);
+                        return;
+                    }
+                }
+                j.code_buffer |= (uint) (b << (24 - j.code_bits));
+                j.code_bits += (int) (8);
+            } while (j.code_bits <= 24);
+        }
+
+        public static int stbi__jpeg_huff_decode(stbi__jpeg j, stbi__huffman* h)
+        {
+            uint temp;
+            int c;
+            int k;
+            if ((j.code_bits) < (16)) stbi__grow_buffer_unsafe(j);
+            c = (int) ((j.code_buffer >> (32 - 9)) & ((1 << 9) - 1));
+            k = (int) (h->fast[c]);
+            if ((k) < (255))
+            {
+                int s = (int) (h->size[k]);
+                if ((s) > (j.code_bits)) return (int) (-1);
+                j.code_buffer <<= s;
+                j.code_bits -= (int) (s);
+                return (int) (h->values[k]);
+            }
+
+            temp = (uint) (j.code_buffer >> 16);
+            for (k = (int) (9 + 1);; ++k)
+            {
+                if ((temp) < (h->maxcode[k])) break;
+            }
+            if ((k) == (17))
+            {
+                j.code_bits -= (int) (16);
+                return (int) (-1);
+            }
+
+            if ((k) > (j.code_bits)) return (int) (-1);
+            c = (int) (((j.code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]);
+            j.code_bits -= (int) (k);
+            j.code_buffer <<= k;
+            return (int) (h->values[c]);
+        }
+
+        public static int stbi__extend_receive(stbi__jpeg j, int n)
+        {
+            uint k;
+            int sgn;
+            if ((j.code_bits) < (n)) stbi__grow_buffer_unsafe(j);
+            sgn = (int) ((int) j.code_buffer >> 31);
+            k = (uint) (_lrotl(j.code_buffer, (int) (n)));
+            j.code_buffer = (uint) (k & ~stbi__bmask[n]);
+            k &= (uint) (stbi__bmask[n]);
+            j.code_bits -= (int) (n);
+            return (int) (k + (stbi__jbias[n] & ~sgn));
+        }
+
+        public static int stbi__jpeg_get_bits(stbi__jpeg j, int n)
+        {
+            uint k;
+            if ((j.code_bits) < (n)) stbi__grow_buffer_unsafe(j);
+            k = (uint) (_lrotl(j.code_buffer, (int) (n)));
+            j.code_buffer = (uint) (k & ~stbi__bmask[n]);
+            k &= (uint) (stbi__bmask[n]);
+            j.code_bits -= (int) (n);
+            return (int) (k);
+        }
+
+        public static int stbi__jpeg_get_bit(stbi__jpeg j)
+        {
+            uint k;
+            if ((j.code_bits) < (1)) stbi__grow_buffer_unsafe(j);
+            k = (uint) (j.code_buffer);
+            j.code_buffer <<= 1;
+            --j.code_bits;
+            return (int) (k & 0x80000000);
+        }
+
+        public static int stbi__jpeg_decode_block(stbi__jpeg j, short* data, stbi__huffman* hdc, stbi__huffman* hac,
+            short* fac, int b, ushort* dequant)
+        {
+            int diff;
+            int dc;
+            int k;
+            int t;
+            if ((j.code_bits) < (16)) stbi__grow_buffer_unsafe(j);
+            t = (int) (stbi__jpeg_huff_decode(j, hdc));
+            if ((t) < (0)) return (int) (stbi__err("bad huffman code"));
+            memset(data, (int) (0), (ulong) (64*sizeof (short)));
+            diff = (int) ((t) != 0 ? stbi__extend_receive(j, (int) (t)) : 0);
+            dc = (int) (j.img_comp[b].dc_pred + diff);
+            j.img_comp[b].dc_pred = (int) (dc);
+            data[0] = ((short) (dc*dequant[0]));
+            k = (int) (1);
+            do
+            {
+                uint zig;
+                int c;
+                int r;
+                int s;
+                if ((j.code_bits) < (16)) stbi__grow_buffer_unsafe(j);
+                c = (int) ((j.code_buffer >> (32 - 9)) & ((1 << 9) - 1));
+                r = (int) (fac[c]);
+                if ((r) != 0)
+                {
+                    k += (int) ((r >> 4) & 15);
+                    s = (int) (r & 15);
+                    j.code_buffer <<= s;
+                    j.code_bits -= (int) (s);
+                    zig = (uint) (stbi__jpeg_dezigzag[k++]);
+                    data[zig] = ((short) ((r >> 8)*dequant[zig]));
+                }
+                else
+                {
+                    int rs = (int) (stbi__jpeg_huff_decode(j, hac));
+                    if ((rs) < (0)) return (int) (stbi__err("bad huffman code"));
+                    s = (int) (rs & 15);
+                    r = (int) (rs >> 4);
+                    if ((s) == (0))
+                    {
+                        if (rs != 0xf0) break;
+                        k += (int) (16);
+                    }
+                    else
+                    {
+                        k += (int) (r);
+                        zig = (uint) (stbi__jpeg_dezigzag[k++]);
+                        data[zig] = ((short) (stbi__extend_receive(j, (int) (s))*dequant[zig]));
+                    }
+                }
+            } while ((k) < (64));
+            return (int) (1);
+        }
+
+        public static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg j, short* data, stbi__huffman* hdc, int b)
+        {
+            int diff;
+            int dc;
+            int t;
+            if (j.spec_end != 0) return (int) (stbi__err("can't merge dc and ac"));
+            if ((j.code_bits) < (16)) stbi__grow_buffer_unsafe(j);
+            if ((j.succ_high) == (0))
+            {
+                memset(data, (int) (0), (ulong) (64*sizeof (short)));
+                t = (int) (stbi__jpeg_huff_decode(j, hdc));
+                diff = (int) ((t) != 0 ? stbi__extend_receive(j, (int) (t)) : 0);
+                dc = (int) (j.img_comp[b].dc_pred + diff);
+                j.img_comp[b].dc_pred = (int) (dc);
+                data[0] = ((short) (dc << j.succ_low));
+            }
+            else
+            {
+                if ((stbi__jpeg_get_bit(j)) != 0) data[0] += ((short) (1 << j.succ_low));
+            }
+
+            return (int) (1);
+        }
+
+        public static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg j, short* data, stbi__huffman* hac, short* fac)
+        {
+            int k;
+            if ((j.spec_start) == (0)) return (int) (stbi__err("can't merge dc and ac"));
+            if ((j.succ_high) == (0))
+            {
+                int shift = (int) (j.succ_low);
+                if ((j.eob_run) != 0)
+                {
+                    --j.eob_run;
+                    return (int) (1);
+                }
+                k = (int) (j.spec_start);
+                do
+                {
+                    uint zig;
+                    int c;
+                    int r;
+                    int s;
+                    if ((j.code_bits) < (16)) stbi__grow_buffer_unsafe(j);
+                    c = (int) ((j.code_buffer >> (32 - 9)) & ((1 << 9) - 1));
+                    r = (int) (fac[c]);
+                    if ((r) != 0)
+                    {
+                        k += (int) ((r >> 4) & 15);
+                        s = (int) (r & 15);
+                        j.code_buffer <<= s;
+                        j.code_bits -= (int) (s);
+                        zig = (uint) (stbi__jpeg_dezigzag[k++]);
+                        data[zig] = ((short) ((r >> 8) << shift));
+                    }
+                    else
+                    {
+                        int rs = (int) (stbi__jpeg_huff_decode(j, hac));
+                        if ((rs) < (0)) return (int) (stbi__err("bad huffman code"));
+                        s = (int) (rs & 15);
+                        r = (int) (rs >> 4);
+                        if ((s) == (0))
+                        {
+                            if ((r) < (15))
+                            {
+                                j.eob_run = (int) (1 << r);
+                                if ((r) != 0) j.eob_run += (int) (stbi__jpeg_get_bits(j, (int) (r)));
+                                --j.eob_run;
+                                break;
+                            }
+                            k += (int) (16);
+                        }
+                        else
+                        {
+                            k += (int) (r);
+                            zig = (uint) (stbi__jpeg_dezigzag[k++]);
+                            data[zig] = ((short) (stbi__extend_receive(j, (int) (s)) << shift));
+                        }
+                    }
+                } while (k <= j.spec_end);
+            }
+            else
+            {
+                short bit = (short) (1 << j.succ_low);
+                if ((j.eob_run) != 0)
+                {
+                    --j.eob_run;
+                    for (k = (int) (j.spec_start); k <= j.spec_end; ++k)
+                    {
+                        short* p = &data[stbi__jpeg_dezigzag[k]];
+                        if (*p != 0)
+                            if ((stbi__jpeg_get_bit(j)) != 0)
+                                if ((*p & bit) == (0))
+                                {
+                                    if ((*p) > (0)) *p += (short) (bit);
+                                    else *p -= (short) (bit);
+                                }
+                    }
+                }
+                else
+                {
+                    k = (int) (j.spec_start);
+                    do
+                    {
+                        int r;
+                        int s;
+                        int rs = (int) (stbi__jpeg_huff_decode(j, hac));
+                        if ((rs) < (0)) return (int) (stbi__err("bad huffman code"));
+                        s = (int) (rs & 15);
+                        r = (int) (rs >> 4);
+                        if ((s) == (0))
+                        {
+                            if ((r) < (15))
+                            {
+                                j.eob_run = (int) ((1 << r) - 1);
+                                if ((r) != 0) j.eob_run += (int) (stbi__jpeg_get_bits(j, (int) (r)));
+                                r = (int) (64);
+                            }
+                            else
+                            {
+                            }
+                        }
+                        else
+                        {
+                            if (s != 1) return (int) (stbi__err("bad huffman code"));
+                            if ((stbi__jpeg_get_bit(j)) != 0) s = (int) (bit);
+                            else s = (int) (-bit);
+                        }
+                        while (k <= j.spec_end)
+                        {
+                            short* p = &data[stbi__jpeg_dezigzag[k++]];
+                            if (*p != 0)
+                            {
+                                if ((stbi__jpeg_get_bit(j)) != 0)
+                                    if ((*p & bit) == (0))
+                                    {
+                                        if ((*p) > (0)) *p += (short) (bit);
+                                        else *p -= (short) (bit);
+                                    }
+                            }
+                            else
+                            {
+                                if ((r) == (0))
+                                {
+                                    *p = ((short) (s));
+                                    break;
+                                }
+                                --r;
+                            }
+                        }
+                    } while (k <= j.spec_end);
+                }
+            }
+
+            return (int) (1);
+        }
+
+        public static byte stbi__clamp(int x)
+        {
+            if (((uint) (x)) > (255))
+            {
+                if ((x) < (0)) return (byte) (0);
+                if ((x) > (255)) return (byte) (255);
+            }
+
+            return (byte) (x);
+        }
+
+        public static void stbi__idct_block(byte* _out_, int out_stride, short* data)
+        {
+            int i;
+            int* val = stackalloc int[64];
+            int* v = val;
+            byte* o;
+            short* d = ((short*) data);
+            for (i = (int) (0); (i) < (8); ++i , ++d , ++v)
+            {
+                if ((((((((d[8]) == (0)) && ((d[16]) == (0))) && ((d[24]) == (0))) && ((d[32]) == (0))) &&
+                      ((d[40]) == (0))) &&
+                     ((d[48]) == (0))) && ((d[56]) == (0)))
+                {
+                    int dcterm = (int) (d[0] << 2);
+                    v[0] =
+                        (int)
+                            (v[8] =
+                                (int)
+                                    (v[16] =
+                                        (int)
+                                            (v[24] =
+                                                (int)
+                                                    (v[32] =
+                                                        (int) (v[40] = (int) (v[48] = (int) (v[56] = (int) (dcterm))))))));
+                }
+                else
+                {
+                    int t0;
+                    int t1;
+                    int t2;
+                    int t3;
+                    int p1;
+                    int p2;
+                    int p3;
+                    int p4;
+                    int p5;
+                    int x0;
+                    int x1;
+                    int x2;
+                    int x3;
+                    p2 = (int) (d[16]);
+                    p3 = (int) (d[48]);
+                    p1 = (int) ((p2 + p3)*((int) ((0.5411961f)*4096 + 0.5)));
+                    t2 = (int) (p1 + p3*((int) ((-1.847759065f)*4096 + 0.5)));
+                    t3 = (int) (p1 + p2*((int) ((0.765366865f)*4096 + 0.5)));
+                    p2 = (int) (d[0]);
+                    p3 = (int) (d[32]);
+                    t0 = (int) ((p2 + p3) << 12);
+                    t1 = (int) ((p2 - p3) << 12);
+                    x0 = (int) (t0 + t3);
+                    x3 = (int) (t0 - t3);
+                    x1 = (int) (t1 + t2);
+                    x2 = (int) (t1 - t2);
+                    t0 = (int) (d[56]);
+                    t1 = (int) (d[40]);
+                    t2 = (int) (d[24]);
+                    t3 = (int) (d[8]);
+                    p3 = (int) (t0 + t2);
+                    p4 = (int) (t1 + t3);
+                    p1 = (int) (t0 + t3);
+                    p2 = (int) (t1 + t2);
+                    p5 = (int) ((p3 + p4)*((int) ((1.175875602f)*4096 + 0.5)));
+                    t0 = (int) (t0*((int) ((0.298631336f)*4096 + 0.5)));
+                    t1 = (int) (t1*((int) ((2.053119869f)*4096 + 0.5)));
+                    t2 = (int) (t2*((int) ((3.072711026f)*4096 + 0.5)));
+                    t3 = (int) (t3*((int) ((1.501321110f)*4096 + 0.5)));
+                    p1 = (int) (p5 + p1*((int) ((-0.899976223f)*4096 + 0.5)));
+                    p2 = (int) (p5 + p2*((int) ((-2.562915447f)*4096 + 0.5)));
+                    p3 = (int) (p3*((int) ((-1.961570560f)*4096 + 0.5)));
+                    p4 = (int) (p4*((int) ((-0.390180644f)*4096 + 0.5)));
+                    t3 += (int) (p1 + p4);
+                    t2 += (int) (p2 + p3);
+                    t1 += (int) (p2 + p4);
+                    t0 += (int) (p1 + p3);
+                    x0 += (int) (512);
+                    x1 += (int) (512);
+                    x2 += (int) (512);
+                    x3 += (int) (512);
+                    v[0] = (int) ((x0 + t3) >> 10);
+                    v[56] = (int) ((x0 - t3) >> 10);
+                    v[8] = (int) ((x1 + t2) >> 10);
+                    v[48] = (int) ((x1 - t2) >> 10);
+                    v[16] = (int) ((x2 + t1) >> 10);
+                    v[40] = (int) ((x2 - t1) >> 10);
+                    v[24] = (int) ((x3 + t0) >> 10);
+                    v[32] = (int) ((x3 - t0) >> 10);
+                }
+            }
+            for (i = (int) (0) , v = val , o = _out_; (i) < (8); ++i , v += 8 , o += out_stride)
+            {
+                int t0;
+                int t1;
+                int t2;
+                int t3;
+                int p1;
+                int p2;
+                int p3;
+                int p4;
+                int p5;
+                int x0;
+                int x1;
+                int x2;
+                int x3;
+                p2 = (int) (v[2]);
+                p3 = (int) (v[6]);
+                p1 = (int) ((p2 + p3)*((int) ((0.5411961f)*4096 + 0.5)));
+                t2 = (int) (p1 + p3*((int) ((-1.847759065f)*4096 + 0.5)));
+                t3 = (int) (p1 + p2*((int) ((0.765366865f)*4096 + 0.5)));
+                p2 = (int) (v[0]);
+                p3 = (int) (v[4]);
+                t0 = (int) ((p2 + p3) << 12);
+                t1 = (int) ((p2 - p3) << 12);
+                x0 = (int) (t0 + t3);
+                x3 = (int) (t0 - t3);
+                x1 = (int) (t1 + t2);
+                x2 = (int) (t1 - t2);
+                t0 = (int) (v[7]);
+                t1 = (int) (v[5]);
+                t2 = (int) (v[3]);
+                t3 = (int) (v[1]);
+                p3 = (int) (t0 + t2);
+                p4 = (int) (t1 + t3);
+                p1 = (int) (t0 + t3);
+                p2 = (int) (t1 + t2);
+                p5 = (int) ((p3 + p4)*((int) ((1.175875602f)*4096 + 0.5)));
+                t0 = (int) (t0*((int) ((0.298631336f)*4096 + 0.5)));
+                t1 = (int) (t1*((int) ((2.053119869f)*4096 + 0.5)));
+                t2 = (int) (t2*((int) ((3.072711026f)*4096 + 0.5)));
+                t3 = (int) (t3*((int) ((1.501321110f)*4096 + 0.5)));
+                p1 = (int) (p5 + p1*((int) ((-0.899976223f)*4096 + 0.5)));
+                p2 = (int) (p5 + p2*((int) ((-2.562915447f)*4096 + 0.5)));
+                p3 = (int) (p3*((int) ((-1.961570560f)*4096 + 0.5)));
+                p4 = (int) (p4*((int) ((-0.390180644f)*4096 + 0.5)));
+                t3 += (int) (p1 + p4);
+                t2 += (int) (p2 + p3);
+                t1 += (int) (p2 + p4);
+                t0 += (int) (p1 + p3);
+                x0 += (int) (65536 + (128 << 17));
+                x1 += (int) (65536 + (128 << 17));
+                x2 += (int) (65536 + (128 << 17));
+                x3 += (int) (65536 + (128 << 17));
+                o[0] = (byte) (stbi__clamp((int) ((x0 + t3) >> 17)));
+                o[7] = (byte) (stbi__clamp((int) ((x0 - t3) >> 17)));
+                o[1] = (byte) (stbi__clamp((int) ((x1 + t2) >> 17)));
+                o[6] = (byte) (stbi__clamp((int) ((x1 - t2) >> 17)));
+                o[2] = (byte) (stbi__clamp((int) ((x2 + t1) >> 17)));
+                o[5] = (byte) (stbi__clamp((int) ((x2 - t1) >> 17)));
+                o[3] = (byte) (stbi__clamp((int) ((x3 + t0) >> 17)));
+                o[4] = (byte) (stbi__clamp((int) ((x3 - t0) >> 17)));
+            }
+        }
+
+        public static byte stbi__get_marker(stbi__jpeg j)
+        {
+            byte x;
+            if (j.marker != 0xff)
+            {
+                x = (byte) (j.marker);
+                j.marker = (byte) (0xff);
+                return (byte) (x);
+            }
+
+            x = (byte) (stbi__get8(j.s));
+            if (x != 0xff) return (byte) (0xff);
+            while ((x) == (0xff))
+            {
+                x = (byte) (stbi__get8(j.s));
+            }
+            return (byte) (x);
+        }
+
+        public static void stbi__jpeg_reset(stbi__jpeg j)
+        {
+            j.code_bits = (int) (0);
+            j.code_buffer = (uint) (0);
+            j.nomore = (int) (0);
+            j.img_comp[0].dc_pred =
+                (int)
+                    (j.img_comp[1].dc_pred = (int) (j.img_comp[2].dc_pred = (int) (j.img_comp[3].dc_pred = (int) (0))));
+            j.marker = (byte) (0xff);
+            j.todo = (int) ((j.restart_interval) != 0 ? j.restart_interval : 0x7fffffff);
+            j.eob_run = (int) (0);
+        }
+
+        public static int stbi__parse_entropy_coded_data(stbi__jpeg z)
+        {
+            stbi__jpeg_reset(z);
+            if (z.progressive == 0)
+            {
+                if ((z.scan_n) == (1))
+                {
+                    int i;
+                    int j;
+                    short* data = stackalloc short[64];
+                    int n = (int) (z.order[0]);
+                    int w = (int) ((z.img_comp[n].x + 7) >> 3);
+                    int h = (int) ((z.img_comp[n].y + 7) >> 3);
+                    for (j = (int) (0); (j) < (h); ++j)
+                    {
+                        for (i = (int) (0); (i) < (w); ++i)
+                        {
+                            int ha = (int) (z.img_comp[n].ha);
+                            if (
+                                stbi__jpeg_decode_block(z, data, (stbi__huffman*) z.huff_dc + z.img_comp[n].hd,
+                                    (stbi__huffman*) z.huff_ac + ha,
+                                    z.fast_ac[ha], (int) (n), (ushort*) z.dequant[z.img_comp[n].tq]) == 0)
+                                return (int) (0);
+                            z.idct_block_kernel(z.img_comp[n].data + z.img_comp[n].w2*j*8 + i*8,
+                                (int) (z.img_comp[n].w2), data);
+                            if (--z.todo <= 0)
+                            {
+                                if ((z.code_bits) < (24)) stbi__grow_buffer_unsafe(z);
+                                if (!(((z.marker) >= (0xd0)) && ((z.marker) <= 0xd7))) return (int) (1);
+                                stbi__jpeg_reset(z);
+                            }
+                        }
+                    }
+                    return (int) (1);
+                }
+                else
+                {
+                    int i;
+                    int j;
+                    int k;
+                    int x;
+                    int y;
+                    short* data = stackalloc short[64];
+                    for (j = (int) (0); (j) < (z.img_mcu_y); ++j)
+                    {
+                        for (i = (int) (0); (i) < (z.img_mcu_x); ++i)
+                        {
+                            for (k = (int) (0); (k) < (z.scan_n); ++k)
+                            {
+                                int n = (int) (z.order[k]);
+                                for (y = (int) (0); (y) < (z.img_comp[n].v); ++y)
+                                {
+                                    for (x = (int) (0); (x) < (z.img_comp[n].h); ++x)
+                                    {
+                                        int x2 = (int) ((i*z.img_comp[n].h + x)*8);
+                                        int y2 = (int) ((j*z.img_comp[n].v + y)*8);
+                                        int ha = (int) (z.img_comp[n].ha);
+                                        if (
+                                            stbi__jpeg_decode_block(z, data,
+                                                (stbi__huffman*) z.huff_dc + z.img_comp[n].hd,
+                                                (stbi__huffman*) z.huff_ac + ha, z.fast_ac[ha], (int) (n),
+                                                (ushort*) z.dequant[z.img_comp[n].tq]) == 0)
+                                            return (int) (0);
+                                        z.idct_block_kernel(z.img_comp[n].data + z.img_comp[n].w2*y2 + x2,
+                                            (int) (z.img_comp[n].w2), data);
+                                    }
+                                }
+                            }
+                            if (--z.todo <= 0)
+                            {
+                                if ((z.code_bits) < (24)) stbi__grow_buffer_unsafe(z);
+                                if (!(((z.marker) >= (0xd0)) && ((z.marker) <= 0xd7))) return (int) (1);
+                                stbi__jpeg_reset(z);
+                            }
+                        }
+                    }
+                    return (int) (1);
+                }
+            }
+            else
+            {
+                if ((z.scan_n) == (1))
+                {
+                    int i;
+                    int j;
+                    int n = (int) (z.order[0]);
+                    int w = (int) ((z.img_comp[n].x + 7) >> 3);
+                    int h = (int) ((z.img_comp[n].y + 7) >> 3);
+                    for (j = (int) (0); (j) < (h); ++j)
+                    {
+                        for (i = (int) (0); (i) < (w); ++i)
+                        {
+                            short* data = z.img_comp[n].coeff + 64*(i + j*z.img_comp[n].coeff_w);
+                            if ((z.spec_start) == (0))
+                            {
+                                if (
+                                    stbi__jpeg_decode_block_prog_dc(z, data,
+                                        (stbi__huffman*) z.huff_dc + z.img_comp[n].hd, (int) (n)) == 0)
+                                    return (int) (0);
+                            }
+                            else
+                            {
+                                int ha = (int) (z.img_comp[n].ha);
+                                if (
+                                    stbi__jpeg_decode_block_prog_ac(z, data, (stbi__huffman*) z.huff_ac + ha,
+                                        z.fast_ac[ha]) == 0)
+                                    return (int) (0);
+                            }
+                            if (--z.todo <= 0)
+                            {
+                                if ((z.code_bits) < (24)) stbi__grow_buffer_unsafe(z);
+                                if (!(((z.marker) >= (0xd0)) && ((z.marker) <= 0xd7))) return (int) (1);
+                                stbi__jpeg_reset(z);
+                            }
+                        }
+                    }
+                    return (int) (1);
+                }
+                else
+                {
+                    int i;
+                    int j;
+                    int k;
+                    int x;
+                    int y;
+                    for (j = (int) (0); (j) < (z.img_mcu_y); ++j)
+                    {
+                        for (i = (int) (0); (i) < (z.img_mcu_x); ++i)
+                        {
+                            for (k = (int) (0); (k) < (z.scan_n); ++k)
+                            {
+                                int n = (int) (z.order[k]);
+                                for (y = (int) (0); (y) < (z.img_comp[n].v); ++y)
+                                {
+                                    for (x = (int) (0); (x) < (z.img_comp[n].h); ++x)
+                                    {
+                                        int x2 = (int) (i*z.img_comp[n].h + x);
+                                        int y2 = (int) (j*z.img_comp[n].v + y);
+                                        short* data = z.img_comp[n].coeff + 64*(x2 + y2*z.img_comp[n].coeff_w);
+                                        if (
+                                            stbi__jpeg_decode_block_prog_dc(z, data,
+                                                (stbi__huffman*) z.huff_dc + z.img_comp[n].hd, (int) (n)) == 0)
+                                            return (int) (0);
+                                    }
+                                }
+                            }
+                            if (--z.todo <= 0)
+                            {
+                                if ((z.code_bits) < (24)) stbi__grow_buffer_unsafe(z);
+                                if (!(((z.marker) >= (0xd0)) && ((z.marker) <= 0xd7))) return (int) (1);
+                                stbi__jpeg_reset(z);
+                            }
+                        }
+                    }
+                    return (int) (1);
+                }
+            }
+
+        }
+
+        public static void stbi__jpeg_dequantize(short* data, ushort* dequant)
+        {
+            int i;
+            for (i = (int) (0); (i) < (64); ++i)
+            {
+                data[i] *= (short) (dequant[i]);
+            }
+        }
+
+        public static void stbi__jpeg_finish(stbi__jpeg z)
+        {
+            if ((z.progressive) != 0)
+            {
+                int i;
+                int j;
+                int n;
+                for (n = (int) (0); (n) < (z.s.img_n); ++n)
+                {
+                    int w = (int) ((z.img_comp[n].x + 7) >> 3);
+                    int h = (int) ((z.img_comp[n].y + 7) >> 3);
+                    for (j = (int) (0); (j) < (h); ++j)
+                    {
+                        for (i = (int) (0); (i) < (w); ++i)
+                        {
+                            short* data = z.img_comp[n].coeff + 64*(i + j*z.img_comp[n].coeff_w);
+                            stbi__jpeg_dequantize(data, (ushort*) z.dequant[z.img_comp[n].tq]);
+                            z.idct_block_kernel(z.img_comp[n].data + z.img_comp[n].w2*j*8 + i*8,
+                                (int) (z.img_comp[n].w2), data);
+                        }
+                    }
+                }
+            }
+
+        }
+
+        public static int stbi__process_marker(stbi__jpeg z, int m)
+        {
+            int L;
+            switch (m)
+            {
+                case 0xff:
+                    return (int) (stbi__err("expected marker"));
+                case 0xDD:
+                    if (stbi__get16be(z.s) != 4) return (int) (stbi__err("bad DRI len"));
+                    z.restart_interval = (int) (stbi__get16be(z.s));
+                    return (int) (1);
+                case 0xDB:
+                    L = (int) (stbi__get16be(z.s) - 2);
+                    while ((L) > (0))
+                    {
+                        int q = (int) (stbi__get8(z.s));
+                        int p = (int) (q >> 4);
+                        int sixteen = (p != 0) ? 1 : 0;
+                        int t = (int) (q & 15);
+                        int i;
+                        if ((p != 0) && (p != 1)) return (int) (stbi__err("bad DQT type"));
+                        if ((t) > (3)) return (int) (stbi__err("bad DQT table"));
+                        for (i = (int) (0); (i) < (64); ++i)
+                        {
+                            z.dequant[t][stbi__jpeg_dezigzag[i]] =
+                                ((ushort) ((sixteen) != 0 ? stbi__get16be(z.s) : stbi__get8(z.s)));
+                        }
+                        L -= (int) ((sixteen) != 0 ? 129 : 65);
+                    }
+                    return (int) ((L) == (0) ? 1 : 0);
+                case 0xC4:
+                    L = (int) (stbi__get16be(z.s) - 2);
+                    while ((L) > (0))
+                    {
+                        byte* v;
+                        int* sizes = stackalloc int[16];
+                        int i;
+                        int n = (int) (0);
+                        int q = (int) (stbi__get8(z.s));
+                        int tc = (int) (q >> 4);
+                        int th = (int) (q & 15);
+                        if (((tc) > (1)) || ((th) > (3))) return (int) (stbi__err("bad DHT header"));
+                        for (i = (int) (0); (i) < (16); ++i)
+                        {
+                            sizes[i] = (int) (stbi__get8(z.s));
+                            n += (int) (sizes[i]);
+                        }
+                        L -= (int) (17);
+                        if ((tc) == (0))
+                        {
+                            if (stbi__build_huffman((stbi__huffman*) z.huff_dc + th, sizes) == 0) return (int) (0);
+                            stbi__huffman* h = (stbi__huffman*) z.huff_dc + th;
+                            v = h->values;
+                        }
+                        else
+                        {
+                            if (stbi__build_huffman((stbi__huffman*) z.huff_ac + th, sizes) == 0) return (int) (0);
+                            stbi__huffman* h = (stbi__huffman*) z.huff_ac + th;
+                            v = h->values;
+                        }
+                        for (i = (int) (0); (i) < (n); ++i)
+                        {
+                            v[i] = (byte) (stbi__get8(z.s));
+                        }
+                        if (tc != 0) stbi__build_fast_ac(z.fast_ac[th], (stbi__huffman*) z.huff_ac + th);
+                        L -= (int) (n);
+                    }
+                    return (int) ((L) == (0) ? 1 : 0);
+            }
+
+            if ((((m) >= (0xE0)) && (m <= 0xEF)) || ((m) == (0xFE)))
+            {
+                L = (int) (stbi__get16be(z.s));
+                if ((L) < (2))
+                {
+                    if ((m) == (0xFE)) return (int) (stbi__err("bad COM len"));
+                    else return (int) (stbi__err("bad APP len"));
+                }
+                L -= (int) (2);
+                if (((m) == (0xE0)) && ((L) >= (5)))
+                {
+                    byte* tag = stackalloc byte[5];
+                    tag[0] = (byte) ('J');
+                    tag[1] = (byte) ('F');
+                    tag[2] = (byte) ('I');
+                    tag[3] = (byte) ('F');
+                    tag[4] = (byte) ('\0');
+                    int ok = (int) (1);
+                    int i;
+                    for (i = (int) (0); (i) < (5); ++i)
+                    {
+                        if (stbi__get8(z.s) != tag[i]) ok = (int) (0);
+                    }
+                    L -= (int) (5);
+                    if ((ok) != 0) z.jfif = (int) (1);
+                }
+                else if (((m) == (0xEE)) && ((L) >= (12)))
+                {
+                    byte* tag = stackalloc byte[6];
+                    tag[0] = (byte) ('A');
+                    tag[1] = (byte) ('d');
+                    tag[2] = (byte) ('o');
+                    tag[3] = (byte) ('b');
+                    tag[4] = (byte) ('e');
+                    tag[5] = (byte) ('\0');
+                    int ok = (int) (1);
+                    int i;
+                    for (i = (int) (0); (i) < (6); ++i)
+                    {
+                        if (stbi__get8(z.s) != tag[i]) ok = (int) (0);
+                    }
+                    L -= (int) (6);
+                    if ((ok) != 0)
+                    {
+                        stbi__get8(z.s);
+                        stbi__get16be(z.s);
+                        stbi__get16be(z.s);
+                        z.app14_color_transform = (int) (stbi__get8(z.s));
+                        L -= (int) (6);
+                    }
+                }
+                stbi__skip(z.s, (int) (L));
+                return (int) (1);
+            }
+
+            return (int) (stbi__err("unknown marker"));
+        }
+
+        public static int stbi__process_scan_header(stbi__jpeg z)
+        {
+            int i;
+            int Ls = (int) (stbi__get16be(z.s));
+            z.scan_n = (int) (stbi__get8(z.s));
+            if ((((z.scan_n) < (1)) || ((z.scan_n) > (4))) || ((z.scan_n) > (z.s.img_n)))
+                return (int) (stbi__err("bad SOS component count"));
+            if (Ls != 6 + 2*z.scan_n) return (int) (stbi__err("bad SOS len"));
+            for (i = (int) (0); (i) < (z.scan_n); ++i)
+            {
+                int id = (int) (stbi__get8(z.s));
+                int which;
+                int q = (int) (stbi__get8(z.s));
+                for (which = (int) (0); (which) < (z.s.img_n); ++which)
+                {
+                    if ((z.img_comp[which].id) == (id)) break;
+                }
+                if ((which) == (z.s.img_n)) return (int) (0);
+                z.img_comp[which].hd = (int) (q >> 4);
+                if ((z.img_comp[which].hd) > (3)) return (int) (stbi__err("bad DC huff"));
+                z.img_comp[which].ha = (int) (q & 15);
+                if ((z.img_comp[which].ha) > (3)) return (int) (stbi__err("bad AC huff"));
+                z.order[i] = (int) (which);
+            }
+            {
+                int aa;
+                z.spec_start = (int) (stbi__get8(z.s));
+                z.spec_end = (int) (stbi__get8(z.s));
+                aa = (int) (stbi__get8(z.s));
+                z.succ_high = (int) (aa >> 4);
+                z.succ_low = (int) (aa & 15);
+                if ((z.progressive) != 0)
+                {
+                    if ((((((z.spec_start) > (63)) || ((z.spec_end) > (63))) || ((z.spec_start) > (z.spec_end))) ||
+                         ((z.succ_high) > (13))) || ((z.succ_low) > (13))) return (int) (stbi__err("bad SOS"));
+                }
+                else
+                {
+                    if (z.spec_start != 0) return (int) (stbi__err("bad SOS"));
+                    if ((z.succ_high != 0) || (z.succ_low != 0)) return (int) (stbi__err("bad SOS"));
+                    z.spec_end = (int) (63);
+                }
+            }
+
+            return (int) (1);
+        }
+
+        public static int stbi__free_jpeg_components(stbi__jpeg z, int ncomp, int why)
+        {
+            int i;
+            for (i = (int) (0); (i) < (ncomp); ++i)
+            {
+                if ((z.img_comp[i].raw_data) != null)
+                {
+                    free(z.img_comp[i].raw_data);
+                    z.img_comp[i].raw_data = (null);
+                    z.img_comp[i].data = (null);
+                }
+                if ((z.img_comp[i].raw_coeff) != null)
+                {
+                    free(z.img_comp[i].raw_coeff);
+                    z.img_comp[i].raw_coeff = null;
+                    z.img_comp[i].coeff = null;
+                }
+                if ((z.img_comp[i].linebuf) != null)
+                {
+                    free(z.img_comp[i].linebuf);
+                    z.img_comp[i].linebuf = (null);
+                }
+            }
+            return (int) (why);
+        }
+
+        public static int stbi__process_frame_header(stbi__jpeg z, int scan)
+        {
+            stbi__context s = z.s;
+            int Lf;
+            int p;
+            int i;
+            int q;
+            int h_max = (int) (1);
+            int v_max = (int) (1);
+            int c;
+            Lf = (int) (stbi__get16be(s));
+            if ((Lf) < (11)) return (int) (stbi__err("bad SOF len"));
+            p = (int) (stbi__get8(s));
+            if (p != 8) return (int) (stbi__err("only 8-bit"));
+            s.img_y = (uint) (stbi__get16be(s));
+            if ((s.img_y) == (0)) return (int) (stbi__err("no header height"));
+            s.img_x = (uint) (stbi__get16be(s));
+            if ((s.img_x) == (0)) return (int) (stbi__err("0 width"));
+            c = (int) (stbi__get8(s));
+            if (((c != 3) && (c != 1)) && (c != 4)) return (int) (stbi__err("bad component count"));
+            s.img_n = (int) (c);
+            for (i = (int) (0); (i) < (c); ++i)
+            {
+                z.img_comp[i].data = (null);
+                z.img_comp[i].linebuf = (null);
+            }
+            if (Lf != 8 + 3*s.img_n) return (int) (stbi__err("bad SOF len"));
+            z.rgb = (int) (0);
+            for (i = (int) (0); (i) < (s.img_n); ++i)
+            {
+                byte* rgb = stackalloc byte[3];
+                rgb[0] = (byte) ('R');
+                rgb[1] = (byte) ('G');
+                rgb[2] = (byte) ('B');
+                z.img_comp[i].id = (int) (stbi__get8(s));
+                if (((s.img_n) == (3)) && ((z.img_comp[i].id) == (rgb[i]))) ++z.rgb;
+                q = (int) (stbi__get8(s));
+                z.img_comp[i].h = (int) (q >> 4);
+                if ((z.img_comp[i].h == 0) || ((z.img_comp[i].h) > (4))) return (int) (stbi__err("bad H"));
+                z.img_comp[i].v = (int) (q & 15);
+                if ((z.img_comp[i].v == 0) || ((z.img_comp[i].v) > (4))) return (int) (stbi__err("bad V"));
+                z.img_comp[i].tq = (int) (stbi__get8(s));
+                if ((z.img_comp[i].tq) > (3)) return (int) (stbi__err("bad TQ"));
+            }
+            if (scan != STBI__SCAN_load) return (int) (1);
+            if (stbi__mad3sizes_valid((int) (s.img_x), (int) (s.img_y), (int) (s.img_n), (int) (0)) == 0)
+                return (int) (stbi__err("too large"));
+            for (i = (int) (0); (i) < (s.img_n); ++i)
+            {
+                if ((z.img_comp[i].h) > (h_max)) h_max = (int) (z.img_comp[i].h);
+                if ((z.img_comp[i].v) > (v_max)) v_max = (int) (z.img_comp[i].v);
+            }
+            z.img_h_max = (int) (h_max);
+            z.img_v_max = (int) (v_max);
+            z.img_mcu_w = (int) (h_max*8);
+            z.img_mcu_h = (int) (v_max*8);
+            z.img_mcu_x = (int) ((s.img_x + z.img_mcu_w - 1)/z.img_mcu_w);
+            z.img_mcu_y = (int) ((s.img_y + z.img_mcu_h - 1)/z.img_mcu_h);
+            for (i = (int) (0); (i) < (s.img_n); ++i)
+            {
+                z.img_comp[i].x = (int) ((s.img_x*z.img_comp[i].h + h_max - 1)/h_max);
+                z.img_comp[i].y = (int) ((s.img_y*z.img_comp[i].v + v_max - 1)/v_max);
+                z.img_comp[i].w2 = (int) (z.img_mcu_x*z.img_comp[i].h*8);
+                z.img_comp[i].h2 = (int) (z.img_mcu_y*z.img_comp[i].v*8);
+                z.img_comp[i].coeff = null;
+                z.img_comp[i].raw_coeff = null;
+                z.img_comp[i].linebuf = (null);
+                z.img_comp[i].raw_data = stbi__malloc_mad2((int) (z.img_comp[i].w2), (int) (z.img_comp[i].h2),
+                    (int) (15));
+                if ((z.img_comp[i].raw_data) == (null))
+                    return (int) (stbi__free_jpeg_components(z, (int) (i + 1), (int) (stbi__err("outofmem"))));
+                z.img_comp[i].data = (byte*) ((((long) z.img_comp[i].raw_data + 15) & ~15));
+                if ((z.progressive) != 0)
+                {
+                    z.img_comp[i].coeff_w = (int) (z.img_comp[i].w2/8);
+                    z.img_comp[i].coeff_h = (int) (z.img_comp[i].h2/8);
+                    z.img_comp[i].raw_coeff = stbi__malloc_mad3((int) (z.img_comp[i].w2), (int) (z.img_comp[i].h2),
+                        (int) (2),
+                        (int) (15));
+                    if ((z.img_comp[i].raw_coeff) == (null))
+                        return (int) (stbi__free_jpeg_components(z, (int) (i + 1), (int) (stbi__err("outofmem"))));
+                    z.img_comp[i].coeff = (short*) ((((long) z.img_comp[i].raw_coeff + 15) & ~15));
+                }
+            }
+            return (int) (1);
+        }
+
+        public static int stbi__decode_jpeg_header(stbi__jpeg z, int scan)
+        {
+            int m;
+            z.jfif = (int) (0);
+            z.app14_color_transform = (int) (-1);
+            z.marker = (byte) (0xff);
+            m = (int) (stbi__get_marker(z));
+            if (!((m) == (0xd8))) return (int) (stbi__err("no SOI"));
+            if ((scan) == (STBI__SCAN_type)) return (int) (1);
+            m = (int) (stbi__get_marker(z));
+            while (!((((m) == (0xc0)) || ((m) == (0xc1))) || ((m) == (0xc2))))
+            {
+                if (stbi__process_marker(z, (int) (m)) == 0) return (int) (0);
+                m = (int) (stbi__get_marker(z));
+                while ((m) == (0xff))
+                {
+                    if ((stbi__at_eof(z.s)) != 0) return (int) (stbi__err("no SOF"));
+                    m = (int) (stbi__get_marker(z));
+                }
+            }
+            z.progressive = (int) ((m) == (0xc2) ? 1 : 0);
+            if (stbi__process_frame_header(z, (int) (scan)) == 0) return (int) (0);
+            return (int) (1);
+        }
+
+        public static int stbi__decode_jpeg_image(stbi__jpeg j)
+        {
+            int m;
+            for (m = (int) (0); (m) < (4); m++)
+            {
+                j.img_comp[m].raw_data = (null);
+                j.img_comp[m].raw_coeff = (null);
+            }
+            j.restart_interval = (int) (0);
+            if (stbi__decode_jpeg_header(j, (int) (STBI__SCAN_load)) == 0) return (int) (0);
+            m = (int) (stbi__get_marker(j));
+            while (!((m) == (0xd9)))
+            {
+                if (((m) == (0xda)))
+                {
+                    if (stbi__process_scan_header(j) == 0) return (int) (0);
+                    if (stbi__parse_entropy_coded_data(j) == 0) return (int) (0);
+                    if ((j.marker) == (0xff))
+                    {
+                        while (stbi__at_eof(j.s) == 0)
+                        {
+                            int x = (int) (stbi__get8(j.s));
+                            if ((x) == (255))
+                            {
+                                j.marker = (byte) (stbi__get8(j.s));
+                                break;
+                            }
+                        }
+                    }
+                }
+                else if (((m) == (0xdc)))
+                {
+                    int Ld = (int) (stbi__get16be(j.s));
+                    uint NL = (uint) (stbi__get16be(j.s));
+                    if (Ld != 4) stbi__err("bad DNL len");
+                    if (NL != j.s.img_y) stbi__err("bad DNL height");
+                }
+                else
+                {
+                    if (stbi__process_marker(j, (int) (m)) == 0) return (int) (0);
+                }
+                m = (int) (stbi__get_marker(j));
+            }
+            if ((j.progressive) != 0) stbi__jpeg_finish(j);
+            return (int) (1);
+        }
+
+        public static byte* resample_row_1(byte* _out_, byte* in_near, byte* in_far, int w, int hs)
+        {
+            return in_near;
+        }
+
+        public static byte* stbi__resample_row_v_2(byte* _out_, byte* in_near, byte* in_far, int w, int hs)
+        {
+            int i;
+            for (i = (int) (0); (i) < (w); ++i)
+            {
+                _out_[i] = ((byte) ((3*in_near[i] + in_far[i] + 2) >> 2));
+            }
+            return _out_;
+        }
+
+        public static byte* stbi__resample_row_h_2(byte* _out_, byte* in_near, byte* in_far, int w, int hs)
+        {
+            int i;
+            byte* input = in_near;
+            if ((w) == (1))
+            {
+                _out_[0] = (byte) (_out_[1] = (byte) (input[0]));
+                return _out_;
+            }
+
+            _out_[0] = (byte) (input[0]);
+            _out_[1] = ((byte) ((input[0]*3 + input[1] + 2) >> 2));
+            for (i = (int) (1); (i) < (w - 1); ++i)
+            {
+                int n = (int) (3*input[i] + 2);
+                _out_[i*2 + 0] = ((byte) ((n + input[i - 1]) >> 2));
+                _out_[i*2 + 1] = ((byte) ((n + input[i + 1]) >> 2));
+            }
+            _out_[i*2 + 0] = ((byte) ((input[w - 2]*3 + input[w - 1] + 2) >> 2));
+            _out_[i*2 + 1] = (byte) (input[w - 1]);
+            return _out_;
+        }
+
+        public static byte* stbi__resample_row_hv_2(byte* _out_, byte* in_near, byte* in_far, int w, int hs)
+        {
+            int i;
+            int t0;
+            int t1;
+            if ((w) == (1))
+            {
+                _out_[0] = (byte) (_out_[1] = ((byte) ((3*in_near[0] + in_far[0] + 2) >> 2)));
+                return _out_;
+            }
+
+            t1 = (int) (3*in_near[0] + in_far[0]);
+            _out_[0] = ((byte) ((t1 + 2) >> 2));
+            for (i = (int) (1); (i) < (w); ++i)
+            {
+                t0 = (int) (t1);
+                t1 = (int) (3*in_near[i] + in_far[i]);
+                _out_[i*2 - 1] = ((byte) ((3*t0 + t1 + 8) >> 4));
+                _out_[i*2] = ((byte) ((3*t1 + t0 + 8) >> 4));
+            }
+            _out_[w*2 - 1] = ((byte) ((t1 + 2) >> 2));
+            return _out_;
+        }
+
+        public static byte* stbi__resample_row_generic(byte* _out_, byte* in_near, byte* in_far, int w, int hs)
+        {
+            int i;
+            int j;
+            for (i = (int) (0); (i) < (w); ++i)
+            {
+                for (j = (int) (0); (j) < (hs); ++j)
+                {
+                    _out_[i*hs + j] = (byte) (in_near[i]);
+                }
+            }
+            return _out_;
+        }
+
+        public static void stbi__YCbCr_to_RGB_row(byte* _out_, byte* y, byte* pcb, byte* pcr, int count, int step)
+        {
+            int i;
+            for (i = (int) (0); (i) < (count); ++i)
+            {
+                int y_fixed = (int) ((y[i] << 20) + (1 << 19));
+                int r;
+                int g;
+                int b;
+                int cr = (int) (pcr[i] - 128);
+                int cb = (int) (pcb[i] - 128);
+                r = (int) (y_fixed + cr*(((int) ((1.40200f)*4096.0f + 0.5f)) << 8));
+                g =
+                    (int)
+                        (y_fixed + (cr*-(((int) ((0.71414f)*4096.0f + 0.5f)) << 8)) +
+                         ((cb*-(((int) ((0.34414f)*4096.0f + 0.5f)) << 8)) & 0xffff0000));
+                b = (int) (y_fixed + cb*(((int) ((1.77200f)*4096.0f + 0.5f)) << 8));
+                r >>= 20;
+                g >>= 20;
+                b >>= 20;
+                if (((uint) (r)) > (255))
+                {
+                    if ((r) < (0)) r = (int) (0);
+                    else r = (int) (255);
+                }
+                if (((uint) (g)) > (255))
+                {
+                    if ((g) < (0)) g = (int) (0);
+                    else g = (int) (255);
+                }
+                if (((uint) (b)) > (255))
+                {
+                    if ((b) < (0)) b = (int) (0);
+                    else b = (int) (255);
+                }
+                _out_[0] = ((byte) (r));
+                _out_[1] = ((byte) (g));
+                _out_[2] = ((byte) (b));
+                _out_[3] = (byte) (255);
+                _out_ += step;
+            }
+        }
+
+        public static void stbi__setup_jpeg(stbi__jpeg j)
+        {
+            j.idct_block_kernel = stbi__idct_block;
+            j.YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row;
+            j.resample_row_hv_2_kernel = stbi__resample_row_hv_2;
+        }
+
+        public static void stbi__cleanup_jpeg(stbi__jpeg j)
+        {
+            stbi__free_jpeg_components(j, (int) (j.s.img_n), (int) (0));
+        }
+
+        public static byte stbi__blinn_8x8(byte x, byte y)
+        {
+            uint t = (uint) (x*y + 128);
+            return (byte) ((t + (t >> 8)) >> 8);
+        }
+
+        public static byte* load_jpeg_image(stbi__jpeg z, int* out_x, int* out_y, int* comp, int req_comp)
+        {
+            int n;
+            int decode_n;
+            int is_rgb;
+            z.s.img_n = (int) (0);
+            if (((req_comp) < (0)) || ((req_comp) > (4)))
+                return ((byte*) ((ulong) ((stbi__err("bad req_comp")) != 0 ? ((byte*) null) : (null))));
+            if (stbi__decode_jpeg_image(z) == 0)
+            {
+                stbi__cleanup_jpeg(z);
+                return (null);
+            }
+
+            n = (int) ((req_comp) != 0 ? req_comp : (z.s.img_n) >= (3) ? 3 : 1);
+            is_rgb =
+                (int)
+                    (((z.s.img_n) == (3)) && (((z.rgb) == (3)) || (((z.app14_color_transform) == (0)) && (z.jfif == 0)))
+                        ? 1
+                        : 0);
+            if ((((z.s.img_n) == (3)) && ((n) < (3))) && (is_rgb == 0)) decode_n = (int) (1);
+            else decode_n = (int) (z.s.img_n);
+            {
+                int k;
+                uint i;
+                uint j;
+                byte* output;
+                byte** coutput = stackalloc byte*[4];
+                var res_comp = new stbi__resample[4];
+                for (var kkk = 0; kkk < res_comp.Length; ++kkk) res_comp[kkk] = new stbi__resample();
+                for (k = (int) (0); (k) < (decode_n); ++k)
+                {
+                    stbi__resample r = res_comp[k];
+                    z.img_comp[k].linebuf = (byte*) (stbi__malloc((ulong) (z.s.img_x + 3)));
+                    if (z.img_comp[k].linebuf == null)
+                    {
+                        stbi__cleanup_jpeg(z);
+                        return ((byte*) ((ulong) ((stbi__err("outofmem")) != 0 ? ((byte*) null) : (null))));
+                    }
+                    r.hs = (int) (z.img_h_max/z.img_comp[k].h);
+                    r.vs = (int) (z.img_v_max/z.img_comp[k].v);
+                    r.ystep = (int) (r.vs >> 1);
+                    r.w_lores = (int) ((z.s.img_x + r.hs - 1)/r.hs);
+                    r.ypos = (int) (0);
+                    r.line0 = r.line1 = z.img_comp[k].data;
+                    if (((r.hs) == (1)) && ((r.vs) == (1))) r.resample = resample_row_1;
+                    else if (((r.hs) == (1)) && ((r.vs) == (2))) r.resample = stbi__resample_row_v_2;
+                    else if (((r.hs) == (2)) && ((r.vs) == (1))) r.resample = stbi__resample_row_h_2;
+                    else if (((r.hs) == (2)) && ((r.vs) == (2))) r.resample = z.resample_row_hv_2_kernel;
+                    else r.resample = stbi__resample_row_generic;
+                }
+                output = (byte*) (stbi__malloc_mad3((int) (n), (int) (z.s.img_x), (int) (z.s.img_y), (int) (1)));
+                if (output == null)
+                {
+                    stbi__cleanup_jpeg(z);
+                    return ((byte*) ((ulong) ((stbi__err("outofmem")) != 0 ? ((byte*) null) : (null))));
+                }
+                for (j = (uint) (0); (j) < (z.s.img_y); ++j)
+                {
+                    byte* _out_ = output + n*z.s.img_x*j;
+                    for (k = (int) (0); (k) < (decode_n); ++k)
+                    {
+                        stbi__resample r = res_comp[k];
+                        int y_bot = (int) ((r.ystep) >= (r.vs >> 1) ? 1 : 0);
+                        coutput[k] = r.resample(z.img_comp[k].linebuf, (y_bot) != 0 ? r.line1 : r.line0,
+                            (y_bot) != 0 ? r.line0 : r.line1,
+                            (int) (r.w_lores), (int) (r.hs));
+                        if ((++r.ystep) >= (r.vs))
+                        {
+                            r.ystep = (int) (0);
+                            r.line0 = r.line1;
+                            if ((++r.ypos) < (z.img_comp[k].y)) r.line1 += z.img_comp[k].w2;
+                        }
+                    }
+                    if ((n) >= (3))
+                    {
+                        byte* y = coutput[0];
+                        if ((z.s.img_n) == (3))
+                        {
+                            if ((is_rgb) != 0)
+                            {
+                                for (i = (uint) (0); (i) < (z.s.img_x); ++i)
+                                {
+                                    _out_[0] = (byte) (y[i]);
+                                    _out_[1] = (byte) (coutput[1][i]);
+                                    _out_[2] = (byte) (coutput[2][i]);
+                                    _out_[3] = (byte) (255);
+                                    _out_ += n;
+                                }
+                            }
+                            else
+                            {
+                                z.YCbCr_to_RGB_kernel(_out_, y, coutput[1], coutput[2], (int) (z.s.img_x), (int) (n));
+                            }
+                        }
+                        else if ((z.s.img_n) == (4))
+                        {
+                            if ((z.app14_color_transform) == (0))
+                            {
+                                for (i = (uint) (0); (i) < (z.s.img_x); ++i)
+                                {
+                                    byte m = (byte) (coutput[3][i]);
+                                    _out_[0] = (byte) (stbi__blinn_8x8((byte) (coutput[0][i]), (byte) (m)));
+                                    _out_[1] = (byte) (stbi__blinn_8x8((byte) (coutput[1][i]), (byte) (m)));
+                                    _out_[2] = (byte) (stbi__blinn_8x8((byte) (coutput[2][i]), (byte) (m)));
+                                    _out_[3] = (byte) (255);
+                                    _out_ += n;
+                                }
+                            }
+                            else if ((z.app14_color_transform) == (2))
+                            {
+                                z.YCbCr_to_RGB_kernel(_out_, y, coutput[1], coutput[2], (int) (z.s.img_x), (int) (n));
+                                for (i = (uint) (0); (i) < (z.s.img_x); ++i)
+                                {
+                                    byte m = (byte) (coutput[3][i]);
+                                    _out_[0] = (byte) (stbi__blinn_8x8((byte) (255 - _out_[0]), (byte) (m)));
+                                    _out_[1] = (byte) (stbi__blinn_8x8((byte) (255 - _out_[1]), (byte) (m)));
+                                    _out_[2] = (byte) (stbi__blinn_8x8((byte) (255 - _out_[2]), (byte) (m)));
+                                    _out_ += n;
+                                }
+                            }
+                            else
+                            {
+                                z.YCbCr_to_RGB_kernel(_out_, y, coutput[1], coutput[2], (int) (z.s.img_x), (int) (n));
+                            }
+                        }
+                        else
+                            for (i = (uint) (0); (i) < (z.s.img_x); ++i)
+                            {
+                                _out_[0] = (byte) (_out_[1] = (byte) (_out_[2] = (byte) (y[i])));
+                                _out_[3] = (byte) (255);
+                                _out_ += n;
+                            }
+                    }
+                    else
+                    {
+                        if ((is_rgb) != 0)
+                        {
+                            if ((n) == (1))
+                                for (i = (uint) (0); (i) < (z.s.img_x); ++i)
+                                {
+                                    *_out_++ =
+                                        (byte)
+                                            (stbi__compute_y((int) (coutput[0][i]), (int) (coutput[1][i]),
+                                                (int) (coutput[2][i])));
+                                }
+                            else
+                            {
+                                for (i = (uint) (0); (i) < (z.s.img_x); ++i , _out_ += 2)
+                                {
+                                    _out_[0] =
+                                        (byte)
+                                            (stbi__compute_y((int) (coutput[0][i]), (int) (coutput[1][i]),
+                                                (int) (coutput[2][i])));
+                                    _out_[1] = (byte) (255);
+                                }
+                            }
+                        }
+                        else if (((z.s.img_n) == (4)) && ((z.app14_color_transform) == (0)))
+                        {
+                            for (i = (uint) (0); (i) < (z.s.img_x); ++i)
+                            {
+                                byte m = (byte) (coutput[3][i]);
+                                byte r = (byte) (stbi__blinn_8x8((byte) (coutput[0][i]), (byte) (m)));
+                                byte g = (byte) (stbi__blinn_8x8((byte) (coutput[1][i]), (byte) (m)));
+                                byte b = (byte) (stbi__blinn_8x8((byte) (coutput[2][i]), (byte) (m)));
+                                _out_[0] = (byte) (stbi__compute_y((int) (r), (int) (g), (int) (b)));
+                                _out_[1] = (byte) (255);
+                                _out_ += n;
+                            }
+                        }
+                        else if (((z.s.img_n) == (4)) && ((z.app14_color_transform) == (2)))
+                        {
+                            for (i = (uint) (0); (i) < (z.s.img_x); ++i)
+                            {
+                                _out_[0] =
+                                    (byte) (stbi__blinn_8x8((byte) (255 - coutput[0][i]), (byte) (coutput[3][i])));
+                                _out_[1] = (byte) (255);
+                                _out_ += n;
+                            }
+                        }
+                        else
+                        {
+                            byte* y = coutput[0];
+                            if ((n) == (1))
+                                for (i = (uint) (0); (i) < (z.s.img_x); ++i)
+                                {
+                                    _out_[i] = (byte) (y[i]);
+                                }
+                            else
+                                for (i = (uint) (0); (i) < (z.s.img_x); ++i)
+                                {
+                                    *_out_++ = (byte) (y[i]);
+                                    *_out_++ = (byte) (255);
+                                }
+                        }
+                    }
+                }
+                stbi__cleanup_jpeg(z);
+                *out_x = (int) (z.s.img_x);
+                *out_y = (int) (z.s.img_y);
+                if ((comp) != null) *comp = (int) ((z.s.img_n) >= (3) ? 3 : 1);
+                return output;
+            }
+
+        }
+
+        public static void* stbi__jpeg_load(stbi__context s, int* x, int* y, int* comp, int req_comp,
+            stbi__result_info* ri)
+        {
+            byte* result;
+            stbi__jpeg j = new stbi__jpeg();
+            j.s = s;
+            stbi__setup_jpeg(j);
+            result = load_jpeg_image(j, x, y, comp, (int) (req_comp));
+
+            return result;
+        }
+
+        public static int stbi__jpeg_test(stbi__context s)
+        {
+            int r;
+            stbi__jpeg j = new stbi__jpeg();
+            j.s = s;
+            stbi__setup_jpeg(j);
+            r = (int) (stbi__decode_jpeg_header(j, (int) (STBI__SCAN_type)));
+            stbi__rewind(s);
+
+            return (int) (r);
+        }
+
+        public static int stbi__jpeg_info_raw(stbi__jpeg j, int* x, int* y, int* comp)
+        {
+            if (stbi__decode_jpeg_header(j, (int) (STBI__SCAN_header)) == 0)
+            {
+                stbi__rewind(j.s);
+                return (int) (0);
+            }
+
+            if ((x) != null) *x = (int) (j.s.img_x);
+            if ((y) != null) *y = (int) (j.s.img_y);
+            if ((comp) != null) *comp = (int) ((j.s.img_n) >= (3) ? 3 : 1);
+            return (int) (1);
+        }
+
+        public static int stbi__jpeg_info(stbi__context s, int* x, int* y, int* comp)
+        {
+            int result;
+            stbi__jpeg j = new stbi__jpeg();
+            j.s = s;
+            result = (int) (stbi__jpeg_info_raw(j, x, y, comp));
+
+            return (int) (result);
+        }
+
+        public static int stbi__bitreverse16(int n)
+        {
+            n = (int) (((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1));
+            n = (int) (((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2));
+            n = (int) (((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4));
+            n = (int) (((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8));
+            return (int) (n);
+        }
+
+        public static int stbi__bit_reverse(int v, int bits)
+        {
+            return (int) (stbi__bitreverse16((int) (v)) >> (16 - bits));
+        }
+
+        public static int stbi__zbuild_huffman(stbi__zhuffman* z, byte* sizelist, int num)
+        {
+            int i;
+            int k = (int) (0);
+            int code;
+            int* next_code = stackalloc int[16];
+            int* sizes = stackalloc int[17];
+            memset(sizes, (int) (0), (ulong) (sizeof (int)));
+            memset(((ushort*) (z->fast)), (int) (0), (ulong) ((1 << 9)*sizeof (ushort)));
+            for (i = (int) (0); (i) < (num); ++i)
+            {
+                ++sizes[sizelist[i]];
+            }
+            sizes[0] = (int) (0);
+            for (i = (int) (1); (i) < (16); ++i)
+            {
+                if ((sizes[i]) > (1 << i)) return (int) (stbi__err("bad sizes"));
+            }
+            code = (int) (0);
+            for (i = (int) (1); (i) < (16); ++i)
+            {
+                next_code[i] = (int) (code);
+                z->firstcode[i] = ((ushort) (code));
+                z->firstsymbol[i] = ((ushort) (k));
+                code = (int) (code + sizes[i]);
+                if ((sizes[i]) != 0) if ((code - 1) >= (1 << i)) return (int) (stbi__err("bad codelengths"));
+                z->maxcode[i] = (int) (code << (16 - i));
+                code <<= 1;
+                k += (int) (sizes[i]);
+            }
+            z->maxcode[16] = (int) (0x10000);
+            for (i = (int) (0); (i) < (num); ++i)
+            {
+                int s = (int) (sizelist[i]);
+                if ((s) != 0)
+                {
+                    int c = (int) (next_code[s] - z->firstcode[s] + z->firstsymbol[s]);
+                    ushort fastv = (ushort) ((s << 9) | i);
+                    z->size[c] = ((byte) (s));
+                    z->value[c] = ((ushort) (i));
+                    if (s <= 9)
+                    {
+                        int j = (int) (stbi__bit_reverse((int) (next_code[s]), (int) (s)));
+                        while ((j) < (1 << 9))
+                        {
+                            z->fast[j] = (ushort) (fastv);
+                            j += (int) (1 << s);
+                        }
+                    }
+                    ++next_code[s];
+                }
+            }
+            return (int) (1);
+        }
+
+        public static byte stbi__zget8(stbi__zbuf* z)
+        {
+            if ((z->zbuffer) >= (z->zbuffer_end)) return (byte) (0);
+            return (byte) (*z->zbuffer++);
+        }
+
+        public static void stbi__fill_bits(stbi__zbuf* z)
+        {
+            do
+            {
+                z->code_buffer |= (uint) ((uint) (stbi__zget8(z)) << z->num_bits);
+                z->num_bits += (int) (8);
+            } while (z->num_bits <= 24);
+        }
+
+        public static uint stbi__zreceive(stbi__zbuf* z, int n)
+        {
+            uint k;
+            if ((z->num_bits) < (n)) stbi__fill_bits(z);
+            k = (uint) (z->code_buffer & ((1 << n) - 1));
+            z->code_buffer >>= n;
+            z->num_bits -= (int) (n);
+            return (uint) (k);
+        }
+
+        public static int stbi__zhuffman_decode_slowpath(stbi__zbuf* a, stbi__zhuffman* z)
+        {
+            int b;
+            int s;
+            int k;
+            k = (int) (stbi__bit_reverse((int) (a->code_buffer), (int) (16)));
+            for (s = (int) (9 + 1);; ++s)
+            {
+                if ((k) < (z->maxcode[s])) break;
+            }
+            if ((s) == (16)) return (int) (-1);
+            b = (int) ((k >> (16 - s)) - z->firstcode[s] + z->firstsymbol[s]);
+            a->code_buffer >>= s;
+            a->num_bits -= (int) (s);
+            return (int) (z->value[b]);
+        }
+
+        public static int stbi__zhuffman_decode(stbi__zbuf* a, stbi__zhuffman* z)
+        {
+            int b;
+            int s;
+            if ((a->num_bits) < (16)) stbi__fill_bits(a);
+            b = (int) (z->fast[a->code_buffer & ((1 << 9) - 1)]);
+            if ((b) != 0)
+            {
+                s = (int) (b >> 9);
+                a->code_buffer >>= s;
+                a->num_bits -= (int) (s);
+                return (int) (b & 511);
+            }
+
+            return (int) (stbi__zhuffman_decode_slowpath(a, z));
+        }
+
+        public static int stbi__zexpand(stbi__zbuf* z, sbyte* zout, int n)
+        {
+            sbyte* q;
+            int cur;
+            int limit;
+            int old_limit;
+            z->zout = zout;
+            if (z->z_expandable == 0) return (int) (stbi__err("output buffer limit"));
+            cur = ((int) (z->zout - z->zout_start));
+            limit = (int) (old_limit = ((int) (z->zout_end - z->zout_start)));
+            while ((cur + n) > (limit))
+            {
+                limit *= (int) (2);
+            }
+            q = (sbyte*) (realloc(z->zout_start, (ulong) (limit)));
+            if ((q) == (null)) return (int) (stbi__err("outofmem"));
+            z->zout_start = q;
+            z->zout = q + cur;
+            z->zout_end = q + limit;
+            return (int) (1);
+        }
+
+        public static int stbi__parse_huffman_block(stbi__zbuf* a)
+        {
+            sbyte* zout = a->zout;
+            for (;;)
+            {
+                int z = (int) (stbi__zhuffman_decode(a, &a->z_length));
+                if ((z) < (256))
+                {
+                    if ((z) < (0)) return (int) (stbi__err("bad huffman code"));
+                    if ((zout) >= (a->zout_end))
+                    {
+                        if (stbi__zexpand(a, zout, (int) (1)) == 0) return (int) (0);
+                        zout = a->zout;
+                    }
+                    *zout++ = ((sbyte) (z));
+                }
+                else
+                {
+                    byte* p;
+                    int len;
+                    int dist;
+                    if ((z) == (256))
+                    {
+                        a->zout = zout;
+                        return (int) (1);
+                    }
+                    z -= (int) (257);
+                    len = (int) (stbi__zlength_base[z]);
+                    if ((stbi__zlength_extra[z]) != 0) len += (int) (stbi__zreceive(a, (int) (stbi__zlength_extra[z])));
+                    z = (int) (stbi__zhuffman_decode(a, &a->z_distance));
+                    if ((z) < (0)) return (int) (stbi__err("bad huffman code"));
+                    dist = (int) (stbi__zdist_base[z]);
+                    if ((stbi__zdist_extra[z]) != 0) dist += (int) (stbi__zreceive(a, (int) (stbi__zdist_extra[z])));
+                    if ((zout - a->zout_start) < (dist)) return (int) (stbi__err("bad dist"));
+                    if ((zout + len) > (a->zout_end))
+                    {
+                        if (stbi__zexpand(a, zout, (int) (len)) == 0) return (int) (0);
+                        zout = a->zout;
+                    }
+                    p = (byte*) (zout - dist);
+                    if ((dist) == (1))
+                    {
+                        byte v = (byte) (*p);
+                        if ((len) != 0)
+                        {
+                            do *zout++ = (sbyte) (v); while ((--len) != 0);
+                        }
+                    }
+                    else
+                    {
+                        if ((len) != 0)
+                        {
+                            do *zout++ = (sbyte) (*p++); while ((--len) != 0);
+                        }
+                    }
+                }
+            }
+        }
+
+        public static int stbi__compute_huffman_codes(stbi__zbuf* a)
+        {
+            stbi__zhuffman z_codelength = new stbi__zhuffman();
+            byte* lencodes = stackalloc byte[286 + 32 + 137];
+            byte* codelength_sizes = stackalloc byte[19];
+            int i;
+            int n;
+            int hlit = (int) (stbi__zreceive(a, (int) (5)) + 257);
+            int hdist = (int) (stbi__zreceive(a, (int) (5)) + 1);
+            int hclen = (int) (stbi__zreceive(a, (int) (4)) + 4);
+            int ntot = (int) (hlit + hdist);
+            memset(((byte*) (codelength_sizes)), (int) (0), (ulong) (19*sizeof (byte)));
+            for (i = (int) (0); (i) < (hclen); ++i)
+            {
+                int s = (int) (stbi__zreceive(a, (int) (3)));
+                codelength_sizes[length_dezigzag[i]] = ((byte) (s));
+            }
+            if (stbi__zbuild_huffman(&z_codelength, codelength_sizes, (int) (19)) == 0) return (int) (0);
+            n = (int) (0);
+            while ((n) < (ntot))
+            {
+                int c = (int) (stbi__zhuffman_decode(a, &z_codelength));
+                if (((c) < (0)) || ((c) >= (19))) return (int) (stbi__err("bad codelengths"));
+                if ((c) < (16)) lencodes[n++] = ((byte) (c));
+                else
+                {
+                    byte fill = (byte) (0);
+                    if ((c) == (16))
+                    {
+                        c = (int) (stbi__zreceive(a, (int) (2)) + 3);
+                        if ((n) == (0)) return (int) (stbi__err("bad codelengths"));
+                        fill = (byte) (lencodes[n - 1]);
+                    }
+                    else if ((c) == (17)) c = (int) (stbi__zreceive(a, (int) (3)) + 3);
+                    else
+                    {
+                        c = (int) (stbi__zreceive(a, (int) (7)) + 11);
+                    }
+                    if ((ntot - n) < (c)) return (int) (stbi__err("bad codelengths"));
+                    memset(lencodes + n, (int) (fill), (ulong) (c));
+                    n += (int) (c);
+                }
+            }
+            if (n != ntot) return (int) (stbi__err("bad codelengths"));
+            if (stbi__zbuild_huffman(&a->z_length, lencodes, (int) (hlit)) == 0) return (int) (0);
+            if (stbi__zbuild_huffman(&a->z_distance, lencodes + hlit, (int) (hdist)) == 0) return (int) (0);
+            return (int) (1);
+        }
+
+        public static int stbi__parse_uncompressed_block(stbi__zbuf* a)
+        {
+            byte* header = stackalloc byte[4];
+            int len;
+            int nlen;
+            int k;
+            if ((a->num_bits & 7) != 0) stbi__zreceive(a, (int) (a->num_bits & 7));
+            k = (int) (0);
+            while ((a->num_bits) > (0))
+            {
+                header[k++] = ((byte) (a->code_buffer & 255));
+                a->code_buffer >>= 8;
+                a->num_bits -= (int) (8);
+            }
+            while ((k) < (4))
+            {
+                header[k++] = (byte) (stbi__zget8(a));
+            }
+            len = (int) (header[1]*256 + header[0]);
+            nlen = (int) (header[3]*256 + header[2]);
+            if (nlen != (len ^ 0xffff)) return (int) (stbi__err("zlib corrupt"));
+            if ((a->zbuffer + len) > (a->zbuffer_end)) return (int) (stbi__err("read past buffer"));
+            if ((a->zout + len) > (a->zout_end)) if (stbi__zexpand(a, a->zout, (int) (len)) == 0) return (int) (0);
+            memcpy(a->zout, a->zbuffer, (ulong) (len));
+            a->zbuffer += len;
+            a->zout += len;
+            return (int) (1);
+        }
+
+        public static int stbi__parse_zlib_header(stbi__zbuf* a)
+        {
+            int cmf = (int) (stbi__zget8(a));
+            int cm = (int) (cmf & 15);
+            int flg = (int) (stbi__zget8(a));
+            if ((cmf*256 + flg)%31 != 0) return (int) (stbi__err("bad zlib header"));
+            if ((flg & 32) != 0) return (int) (stbi__err("no preset dict"));
+            if (cm != 8) return (int) (stbi__err("bad compression"));
+            return (int) (1);
+        }
+
+        public static int stbi__parse_zlib(stbi__zbuf* a, int parse_header)
+        {
+            int final;
+            int type;
+            if ((parse_header) != 0) if (stbi__parse_zlib_header(a) == 0) return (int) (0);
+            a->num_bits = (int) (0);
+            a->code_buffer = (uint) (0);
+            do
+            {
+                final = (int) (stbi__zreceive(a, (int) (1)));
+                type = (int) (stbi__zreceive(a, (int) (2)));
+                if ((type) == (0))
+                {
+                    if (stbi__parse_uncompressed_block(a) == 0) return (int) (0);
+                }
+                else if ((type) == (3))
+                {
+                    return (int) (0);
+                }
+                else
+                {
+                    if ((type) == (1))
+                    {
+                        fixed (byte* b = stbi__zdefault_length)
+                        {
+                            if (stbi__zbuild_huffman(&a->z_length, b, (int) (288)) == 0) return (int) (0);
+                        }
+                        fixed (byte* b = stbi__zdefault_distance)
+                        {
+                            if (stbi__zbuild_huffman(&a->z_distance, b, (int) (32)) == 0) return (int) (0);
+                        }
+                    }
+                    else
+                    {
+                        if (stbi__compute_huffman_codes(a) == 0) return (int) (0);
+                    }
+                    if (stbi__parse_huffman_block(a) == 0) return (int) (0);
+                }
+            } while (final == 0);
+            return (int) (1);
+        }
+
+        public static int stbi__do_zlib(stbi__zbuf* a, sbyte* obuf, int olen, int exp, int parse_header)
+        {
+            a->zout_start = obuf;
+            a->zout = obuf;
+            a->zout_end = obuf + olen;
+            a->z_expandable = (int) (exp);
+            return (int) (stbi__parse_zlib(a, (int) (parse_header)));
+        }
+
+        public static sbyte* stbi_zlib_decode_malloc_guesssize(sbyte* buffer, int len, int initial_size, int* outlen)
+        {
+            stbi__zbuf a = new stbi__zbuf();
+            sbyte* p = (sbyte*) (stbi__malloc((ulong) (initial_size)));
+            if ((p) == (null)) return (null);
+            a.zbuffer = (byte*) (buffer);
+            a.zbuffer_end = (byte*) (buffer) + len;
+            if ((stbi__do_zlib(&a, p, (int) (initial_size), (int) (1), (int) (1))) != 0)
+            {
+                if ((outlen) != null) *outlen = ((int) (a.zout - a.zout_start));
+                return a.zout_start;
+            }
+            else
+            {
+                free(a.zout_start);
+                return (null);
+            }
+
+        }
+
+        public static sbyte* stbi_zlib_decode_malloc(sbyte* buffer, int len, int* outlen)
+        {
+            return stbi_zlib_decode_malloc_guesssize(buffer, (int) (len), (int) (16384), outlen);
+        }
+
+        public static sbyte* stbi_zlib_decode_malloc_guesssize_headerflag(sbyte* buffer, int len, int initial_size,
+            int* outlen, int parse_header)
+        {
+            stbi__zbuf a = new stbi__zbuf();
+            sbyte* p = (sbyte*) (stbi__malloc((ulong) (initial_size)));
+            if ((p) == (null)) return (null);
+            a.zbuffer = (byte*) (buffer);
+            a.zbuffer_end = (byte*) (buffer) + len;
+            if ((stbi__do_zlib(&a, p, (int) (initial_size), (int) (1), (int) (parse_header))) != 0)
+            {
+                if ((outlen) != null) *outlen = ((int) (a.zout - a.zout_start));
+                return a.zout_start;
+            }
+            else
+            {
+                free(a.zout_start);
+                return (null);
+            }
+
+        }
+
+        public static int stbi_zlib_decode_buffer(sbyte* obuffer, int olen, sbyte* ibuffer, int ilen)
+        {
+            stbi__zbuf a = new stbi__zbuf();
+            a.zbuffer = (byte*) (ibuffer);
+            a.zbuffer_end = (byte*) (ibuffer) + ilen;
+            if ((stbi__do_zlib(&a, obuffer, (int) (olen), (int) (0), (int) (1))) != 0)
+                return (int) (a.zout - a.zout_start);
+            else return (int) (-1);
+        }
+
+        public static sbyte* stbi_zlib_decode_noheader_malloc(sbyte* buffer, int len, int* outlen)
+        {
+            stbi__zbuf a = new stbi__zbuf();
+            sbyte* p = (sbyte*) (stbi__malloc((ulong) (16384)));
+            if ((p) == (null)) return (null);
+            a.zbuffer = (byte*) (buffer);
+            a.zbuffer_end = (byte*) (buffer) + len;
+            if ((stbi__do_zlib(&a, p, (int) (16384), (int) (1), (int) (0))) != 0)
+            {
+                if ((outlen) != null) *outlen = ((int) (a.zout - a.zout_start));
+                return a.zout_start;
+            }
+            else
+            {
+                free(a.zout_start);
+                return (null);
+            }
+
+        }
+
+        public static int stbi_zlib_decode_noheader_buffer(sbyte* obuffer, int olen, sbyte* ibuffer, int ilen)
+        {
+            stbi__zbuf a = new stbi__zbuf();
+            a.zbuffer = (byte*) (ibuffer);
+            a.zbuffer_end = (byte*) (ibuffer) + ilen;
+            if ((stbi__do_zlib(&a, obuffer, (int) (olen), (int) (0), (int) (0))) != 0)
+                return (int) (a.zout - a.zout_start);
+            else return (int) (-1);
+        }
+
+        public static stbi__pngchunk stbi__get_chunk_header(stbi__context s)
+        {
+            stbi__pngchunk c = new stbi__pngchunk();
+            c.length = (uint) (stbi__get32be(s));
+            c.type = (uint) (stbi__get32be(s));
+            return (stbi__pngchunk) (c);
+        }
+
+        public static int stbi__check_png_header(stbi__context s)
+        {
+            int i;
+            for (i = (int) (0); (i) < (8); ++i)
+            {
+                if (stbi__get8(s) != png_sig[i]) return (int) (stbi__err("bad png sig"));
+            }
+            return (int) (1);
+        }
+
+        public static int stbi__paeth(int a, int b, int c)
+        {
+            int p = (int) (a + b - c);
+            int pa = (int) (abs((int) (p - a)));
+            int pb = (int) (abs((int) (p - b)));
+            int pc = (int) (abs((int) (p - c)));
+            if ((pa <= pb) && (pa <= pc)) return (int) (a);
+            if (pb <= pc) return (int) (b);
+            return (int) (c);
+        }
+
+        public static int stbi__create_png_image_raw(stbi__png a, byte* raw, uint raw_len, int out_n, uint x, uint y,
+            int depth, int color)
+        {
+            int bytes = (int) ((depth) == (16) ? 2 : 1);
+            stbi__context s = a.s;
+            uint i;
+            uint j;
+            uint stride = (uint) (x*out_n*bytes);
+            uint img_len;
+            uint img_width_bytes;
+            int k;
+            int img_n = (int) (s.img_n);
+            int output_bytes = (int) (out_n*bytes);
+            int filter_bytes = (int) (img_n*bytes);
+            int width = (int) (x);
+            a._out_ = (byte*) (stbi__malloc_mad3((int) (x), (int) (y), (int) (output_bytes), (int) (0)));
+            if (a._out_ == null) return (int) (stbi__err("outofmem"));
+            img_width_bytes = (uint) (((img_n*x*depth) + 7) >> 3);
+            img_len = (uint) ((img_width_bytes + 1)*y);
+            if ((raw_len) < (img_len)) return (int) (stbi__err("not enough pixels"));
+            for (j = (uint) (0); (j) < (y); ++j)
+            {
+                byte* cur = a._out_ + stride*j;
+                byte* prior;
+                int filter = (int) (*raw++);
+                if ((filter) > (4)) return (int) (stbi__err("invalid filter"));
+                if ((depth) < (8))
+                {
+                    cur += x*out_n - img_width_bytes;
+                    filter_bytes = (int) (1);
+                    width = (int) (img_width_bytes);
+                }
+                prior = cur - stride;
+                if ((j) == (0)) filter = (int) (first_row_filter[filter]);
+                for (k = (int) (0); (k) < (filter_bytes); ++k)
+                {
+                    switch (filter)
+                    {
+                        case STBI__F_none:
+                            cur[k] = (byte) (raw[k]);
+                            break;
+                        case STBI__F_sub:
+                            cur[k] = (byte) (raw[k]);
+                            break;
+                        case STBI__F_up:
+                            cur[k] = ((byte) ((raw[k] + prior[k]) & 255));
+                            break;
+                        case STBI__F_avg:
+                            cur[k] = ((byte) ((raw[k] + (prior[k] >> 1)) & 255));
+                            break;
+                        case STBI__F_paeth:
+                            cur[k] = ((byte) ((raw[k] + stbi__paeth((int) (0), (int) (prior[k]), (int) (0))) & 255));
+                            break;
+                        case STBI__F_avg_first:
+                            cur[k] = (byte) (raw[k]);
+                            break;
+                        case STBI__F_paeth_first:
+                            cur[k] = (byte) (raw[k]);
+                            break;
+                    }
+                }
+                if ((depth) == (8))
+                {
+                    if (img_n != out_n) cur[img_n] = (byte) (255);
+                    raw += img_n;
+                    cur += out_n;
+                    prior += out_n;
+                }
+                else if ((depth) == (16))
+                {
+                    if (img_n != out_n)
+                    {
+                        cur[filter_bytes] = (byte) (255);
+                        cur[filter_bytes + 1] = (byte) (255);
+                    }
+                    raw += filter_bytes;
+                    cur += output_bytes;
+                    prior += output_bytes;
+                }
+                else
+                {
+                    raw += 1;
+                    cur += 1;
+                    prior += 1;
+                }
+                if (((depth) < (8)) || ((img_n) == (out_n)))
+                {
+                    int nk = (int) ((width - 1)*filter_bytes);
+                    switch (filter)
+                    {
+                        case STBI__F_none:
+                            memcpy(cur, raw, (ulong) (nk));
+                            break;
+                        case STBI__F_sub:
+                            for (k = (int) (0); (k) < (nk); ++k)
+                            {
+                                cur[k] = ((byte) ((raw[k] + cur[k - filter_bytes]) & 255));
+                            }
+                            break;
+                        case STBI__F_up:
+                            for (k = (int) (0); (k) < (nk); ++k)
+                            {
+                                cur[k] = ((byte) ((raw[k] + prior[k]) & 255));
+                            }
+                            break;
+                        case STBI__F_avg:
+                            for (k = (int) (0); (k) < (nk); ++k)
+                            {
+                                cur[k] = ((byte) ((raw[k] + ((prior[k] + cur[k - filter_bytes]) >> 1)) & 255));
+                            }
+                            break;
+                        case STBI__F_paeth:
+                            for (k = (int) (0); (k) < (nk); ++k)
+                            {
+                                cur[k] =
+                                    ((byte)
+                                        ((raw[k] +
+                                          stbi__paeth((int) (cur[k - filter_bytes]), (int) (prior[k]),
+                                              (int) (prior[k - filter_bytes]))) &
+                                         255));
+                            }
+                            break;
+                        case STBI__F_avg_first:
+                            for (k = (int) (0); (k) < (nk); ++k)
+                            {
+                                cur[k] = ((byte) ((raw[k] + (cur[k - filter_bytes] >> 1)) & 255));
+                            }
+                            break;
+                        case STBI__F_paeth_first:
+                            for (k = (int) (0); (k) < (nk); ++k)
+                            {
+                                cur[k] =
+                                    ((byte)
+                                        ((raw[k] + stbi__paeth((int) (cur[k - filter_bytes]), (int) (0), (int) (0))) &
+                                         255));
+                            }
+                            break;
+                    }
+                    raw += nk;
+                }
+                else
+                {
+                    switch (filter)
+                    {
+                        case STBI__F_none:
+                            for (i = (uint) (x - 1);
+                                (i) >= (1);
+                                --i , cur[filter_bytes] = (byte) (255) , raw += filter_bytes , cur += output_bytes ,
+                                    prior += output_bytes)
+                            {
+                                for (k = (int) (0); (k) < (filter_bytes); ++k)
+                                {
+                                    cur[k] = (byte) (raw[k]);
+                                }
+                            }
+                            break;
+                        case STBI__F_sub:
+                            for (i = (uint) (x - 1);
+                                (i) >= (1);
+                                --i , cur[filter_bytes] = (byte) (255) , raw += filter_bytes , cur += output_bytes ,
+                                    prior += output_bytes)
+                            {
+                                for (k = (int) (0); (k) < (filter_bytes); ++k)
+                                {
+                                    cur[k] = ((byte) ((raw[k] + cur[k - output_bytes]) & 255));
+                                }
+                            }
+                            break;
+                        case STBI__F_up:
+                            for (i = (uint) (x - 1);
+                                (i) >= (1);
+                                --i , cur[filter_bytes] = (byte) (255) , raw += filter_bytes , cur += output_bytes ,
+                                    prior += output_bytes)
+                            {
+                                for (k = (int) (0); (k) < (filter_bytes); ++k)
+                                {
+                                    cur[k] = ((byte) ((raw[k] + prior[k]) & 255));
+                                }
+                            }
+                            break;
+                        case STBI__F_avg:
+                            for (i = (uint) (x - 1);
+                                (i) >= (1);
+                                --i , cur[filter_bytes] = (byte) (255) , raw += filter_bytes , cur += output_bytes ,
+                                    prior += output_bytes)
+                            {
+                                for (k = (int) (0); (k) < (filter_bytes); ++k)
+                                {
+                                    cur[k] = ((byte) ((raw[k] + ((prior[k] + cur[k - output_bytes]) >> 1)) & 255));
+                                }
+                            }
+                            break;
+                        case STBI__F_paeth:
+                            for (i = (uint) (x - 1);
+                                (i) >= (1);
+                                --i , cur[filter_bytes] = (byte) (255) , raw += filter_bytes , cur += output_bytes ,
+                                    prior += output_bytes)
+                            {
+                                for (k = (int) (0); (k) < (filter_bytes); ++k)
+                                {
+                                    cur[k] =
+                                        ((byte)
+                                            ((raw[k] +
+                                              stbi__paeth((int) (cur[k - output_bytes]), (int) (prior[k]),
+                                                  (int) (prior[k - output_bytes]))) &
+                                             255));
+                                }
+                            }
+                            break;
+                        case STBI__F_avg_first:
+                            for (i = (uint) (x - 1);
+                                (i) >= (1);
+                                --i , cur[filter_bytes] = (byte) (255) , raw += filter_bytes , cur += output_bytes ,
+                                    prior += output_bytes)
+                            {
+                                for (k = (int) (0); (k) < (filter_bytes); ++k)
+                                {
+                                    cur[k] = ((byte) ((raw[k] + (cur[k - output_bytes] >> 1)) & 255));
+                                }
+                            }
+                            break;
+                        case STBI__F_paeth_first:
+                            for (i = (uint) (x - 1);
+                                (i) >= (1);
+                                --i , cur[filter_bytes] = (byte) (255) , raw += filter_bytes , cur += output_bytes ,
+                                    prior += output_bytes)
+                            {
+                                for (k = (int) (0); (k) < (filter_bytes); ++k)
+                                {
+                                    cur[k] =
+                                        ((byte)
+                                            ((raw[k] + stbi__paeth((int) (cur[k - output_bytes]), (int) (0), (int) (0))) &
+                                             255));
+                                }
+                            }
+                            break;
+                    }
+                    if ((depth) == (16))
+                    {
+                        cur = a._out_ + stride*j;
+                        for (i = (uint) (0); (i) < (x); ++i , cur += output_bytes)
+                        {
+                            cur[filter_bytes + 1] = (byte) (255);
+                        }
+                    }
+                }
+            }
+            if ((depth) < (8))
+            {
+                for (j = (uint) (0); (j) < (y); ++j)
+                {
+                    byte* cur = a._out_ + stride*j;
+                    byte* _in_ = a._out_ + stride*j + x*out_n - img_width_bytes;
+                    byte scale = (byte) (((color) == (0)) ? stbi__depth_scale_table[depth] : 1);
+                    if ((depth) == (4))
+                    {
+                        for (k = (int) (x*img_n); (k) >= (2); k -= (int) (2) , ++_in_)
+                        {
+                            *cur++ = (byte) (scale*(*_in_ >> 4));
+                            *cur++ = (byte) (scale*((*_in_) & 0x0f));
+                        }
+                        if ((k) > (0)) *cur++ = (byte) (scale*(*_in_ >> 4));
+                    }
+                    else if ((depth) == (2))
+                    {
+                        for (k = (int) (x*img_n); (k) >= (4); k -= (int) (4) , ++_in_)
+                        {
+                            *cur++ = (byte) (scale*(*_in_ >> 6));
+                            *cur++ = (byte) (scale*((*_in_ >> 4) & 0x03));
+                            *cur++ = (byte) (scale*((*_in_ >> 2) & 0x03));
+                            *cur++ = (byte) (scale*((*_in_) & 0x03));
+                        }
+                        if ((k) > (0)) *cur++ = (byte) (scale*(*_in_ >> 6));
+                        if ((k) > (1)) *cur++ = (byte) (scale*((*_in_ >> 4) & 0x03));
+                        if ((k) > (2)) *cur++ = (byte) (scale*((*_in_ >> 2) & 0x03));
+                    }
+                    else if ((depth) == (1))
+                    {
+                        for (k = (int) (x*img_n); (k) >= (8); k -= (int) (8) , ++_in_)
+                        {
+                            *cur++ = (byte) (scale*(*_in_ >> 7));
+                            *cur++ = (byte) (scale*((*_in_ >> 6) & 0x01));
+                            *cur++ = (byte) (scale*((*_in_ >> 5) & 0x01));
+                            *cur++ = (byte) (scale*((*_in_ >> 4) & 0x01));
+                            *cur++ = (byte) (scale*((*_in_ >> 3) & 0x01));
+                            *cur++ = (byte) (scale*((*_in_ >> 2) & 0x01));
+                            *cur++ = (byte) (scale*((*_in_ >> 1) & 0x01));
+                            *cur++ = (byte) (scale*((*_in_) & 0x01));
+                        }
+                        if ((k) > (0)) *cur++ = (byte) (scale*(*_in_ >> 7));
+                        if ((k) > (1)) *cur++ = (byte) (scale*((*_in_ >> 6) & 0x01));
+                        if ((k) > (2)) *cur++ = (byte) (scale*((*_in_ >> 5) & 0x01));
+                        if ((k) > (3)) *cur++ = (byte) (scale*((*_in_ >> 4) & 0x01));
+                        if ((k) > (4)) *cur++ = (byte) (scale*((*_in_ >> 3) & 0x01));
+                        if ((k) > (5)) *cur++ = (byte) (scale*((*_in_ >> 2) & 0x01));
+                        if ((k) > (6)) *cur++ = (byte) (scale*((*_in_ >> 1) & 0x01));
+                    }
+                    if (img_n != out_n)
+                    {
+                        int q;
+                        cur = a._out_ + stride*j;
+                        if ((img_n) == (1))
+                        {
+                            for (q = (int) (x - 1); (q) >= (0); --q)
+                            {
+                                cur[q*2 + 1] = (byte) (255);
+                                cur[q*2 + 0] = (byte) (cur[q]);
+                            }
+                        }
+                        else
+                        {
+                            for (q = (int) (x - 1); (q) >= (0); --q)
+                            {
+                                cur[q*4 + 3] = (byte) (255);
+                                cur[q*4 + 2] = (byte) (cur[q*3 + 2]);
+                                cur[q*4 + 1] = (byte) (cur[q*3 + 1]);
+                                cur[q*4 + 0] = (byte) (cur[q*3 + 0]);
+                            }
+                        }
+                    }
+                }
+            }
+            else if ((depth) == (16))
+            {
+                byte* cur = a._out_;
+                ushort* cur16 = (ushort*) (cur);
+                for (i = (uint) (0); (i) < (x*y*out_n); ++i , cur16++ , cur += 2)
+                {
+                    *cur16 = (ushort) ((cur[0] << 8) | cur[1]);
+                }
+            }
+
+            return (int) (1);
+        }
+
+        public static int stbi__create_png_image(stbi__png a, byte* image_data, uint image_data_len, int out_n,
+            int depth,
+            int color, int interlaced)
+        {
+            int bytes = (int) ((depth) == (16) ? 2 : 1);
+            int out_bytes = (int) (out_n*bytes);
+            byte* final;
+            int p;
+            if (interlaced == 0)
+                return
+                    (int)
+                        (stbi__create_png_image_raw(a, image_data, (uint) (image_data_len), (int) (out_n),
+                            (uint) (a.s.img_x),
+                            (uint) (a.s.img_y), (int) (depth), (int) (color)));
+            final = (byte*) (stbi__malloc_mad3((int) (a.s.img_x), (int) (a.s.img_y), (int) (out_bytes), (int) (0)));
+            for (p = (int) (0); (p) < (7); ++p)
+            {
+                int* xorig = stackalloc int[7];
+                xorig[0] = (int) (0);
+                xorig[1] = (int) (4);
+                xorig[2] = (int) (0);
+                xorig[3] = (int) (2);
+                xorig[4] = (int) (0);
+                xorig[5] = (int) (1);
+                xorig[6] = (int) (0);
+                int* yorig = stackalloc int[7];
+                yorig[0] = (int) (0);
+                yorig[1] = (int) (0);
+                yorig[2] = (int) (4);
+                yorig[3] = (int) (0);
+                yorig[4] = (int) (2);
+                yorig[5] = (int) (0);
+                yorig[6] = (int) (1);
+                int* xspc = stackalloc int[7];
+                xspc[0] = (int) (8);
+                xspc[1] = (int) (8);
+                xspc[2] = (int) (4);
+                xspc[3] = (int) (4);
+                xspc[4] = (int) (2);
+                xspc[5] = (int) (2);
+                xspc[6] = (int) (1);
+                int* yspc = stackalloc int[7];
+                yspc[0] = (int) (8);
+                yspc[1] = (int) (8);
+                yspc[2] = (int) (8);
+                yspc[3] = (int) (4);
+                yspc[4] = (int) (4);
+                yspc[5] = (int) (2);
+                yspc[6] = (int) (2);
+                int i;
+                int j;
+                int x;
+                int y;
+                x = (int) ((a.s.img_x - xorig[p] + xspc[p] - 1)/xspc[p]);
+                y = (int) ((a.s.img_y - yorig[p] + yspc[p] - 1)/yspc[p]);
+                if (((x) != 0) && ((y) != 0))
+                {
+                    uint img_len = (uint) (((((a.s.img_n*x*depth) + 7) >> 3) + 1)*y);
+                    if (
+                        stbi__create_png_image_raw(a, image_data, (uint) (image_data_len), (int) (out_n), (uint) (x),
+                            (uint) (y),
+                            (int) (depth), (int) (color)) == 0)
+                    {
+                        free(final);
+                        return (int) (0);
+                    }
+                    for (j = (int) (0); (j) < (y); ++j)
+                    {
+                        for (i = (int) (0); (i) < (x); ++i)
+                        {
+                            int out_y = (int) (j*yspc[p] + yorig[p]);
+                            int out_x = (int) (i*xspc[p] + xorig[p]);
+                            memcpy(final + out_y*a.s.img_x*out_bytes + out_x*out_bytes, a._out_ + (j*x + i)*out_bytes,
+                                (ulong) (out_bytes));
+                        }
+                    }
+                    free(a._out_);
+                    image_data += img_len;
+                    image_data_len -= (uint) (img_len);
+                }
+            }
+            a._out_ = final;
+            return (int) (1);
+        }
+
+        public static int stbi__compute_transparency(stbi__png z, byte* tc, int out_n)
+        {
+            stbi__context s = z.s;
+            uint i;
+            uint pixel_count = (uint) (s.img_x*s.img_y);
+            byte* p = z._out_;
+            if ((out_n) == (2))
+            {
+                for (i = (uint) (0); (i) < (pixel_count); ++i)
+                {
+                    p[1] = (byte) ((p[0]) == (tc[0]) ? 0 : 255);
+                    p += 2;
+                }
+            }
+            else
+            {
+                for (i = (uint) (0); (i) < (pixel_count); ++i)
+                {
+                    if ((((p[0]) == (tc[0])) && ((p[1]) == (tc[1]))) && ((p[2]) == (tc[2]))) p[3] = (byte) (0);
+                    p += 4;
+                }
+            }
+
+            return (int) (1);
+        }
+
+        public static int stbi__compute_transparency16(stbi__png z, ushort* tc, int out_n)
+        {
+            stbi__context s = z.s;
+            uint i;
+            uint pixel_count = (uint) (s.img_x*s.img_y);
+            ushort* p = (ushort*) (z._out_);
+            if ((out_n) == (2))
+            {
+                for (i = (uint) (0); (i) < (pixel_count); ++i)
+                {
+                    p[1] = (ushort) ((p[0]) == (tc[0]) ? 0 : 65535);
+                    p += 2;
+                }
+            }
+            else
+            {
+                for (i = (uint) (0); (i) < (pixel_count); ++i)
+                {
+                    if ((((p[0]) == (tc[0])) && ((p[1]) == (tc[1]))) && ((p[2]) == (tc[2]))) p[3] = (ushort) (0);
+                    p += 4;
+                }
+            }
+
+            return (int) (1);
+        }
+
+        public static int stbi__expand_png_palette(stbi__png a, byte* palette, int len, int pal_img_n)
+        {
+            uint i;
+            uint pixel_count = (uint) (a.s.img_x*a.s.img_y);
+            byte* p;
+            byte* temp_out;
+            byte* orig = a._out_;
+            p = (byte*) (stbi__malloc_mad2((int) (pixel_count), (int) (pal_img_n), (int) (0)));
+            if ((p) == (null)) return (int) (stbi__err("outofmem"));
+            temp_out = p;
+            if ((pal_img_n) == (3))
+            {
+                for (i = (uint) (0); (i) < (pixel_count); ++i)
+                {
+                    int n = (int) (orig[i]*4);
+                    p[0] = (byte) (palette[n]);
+                    p[1] = (byte) (palette[n + 1]);
+                    p[2] = (byte) (palette[n + 2]);
+                    p += 3;
+                }
+            }
+            else
+            {
+                for (i = (uint) (0); (i) < (pixel_count); ++i)
+                {
+                    int n = (int) (orig[i]*4);
+                    p[0] = (byte) (palette[n]);
+                    p[1] = (byte) (palette[n + 1]);
+                    p[2] = (byte) (palette[n + 2]);
+                    p[3] = (byte) (palette[n + 3]);
+                    p += 4;
+                }
+            }
+
+            free(a._out_);
+            a._out_ = temp_out;
+            return (int) (1);
+        }
+
+        public static void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
+        {
+            stbi__unpremultiply_on_load = (int) (flag_true_if_should_unpremultiply);
+        }
+
+        public static void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
+        {
+            stbi__de_iphone_flag = (int) (flag_true_if_should_convert);
+        }
+
+        public static void stbi__de_iphone(stbi__png z)
+        {
+            stbi__context s = z.s;
+            uint i;
+            uint pixel_count = (uint) (s.img_x*s.img_y);
+            byte* p = z._out_;
+            if ((s.img_out_n) == (3))
+            {
+                for (i = (uint) (0); (i) < (pixel_count); ++i)
+                {
+                    byte t = (byte) (p[0]);
+                    p[0] = (byte) (p[2]);
+                    p[2] = (byte) (t);
+                    p += 3;
+                }
+            }
+            else
+            {
+                if ((stbi__unpremultiply_on_load) != 0)
+                {
+                    for (i = (uint) (0); (i) < (pixel_count); ++i)
+                    {
+                        byte a = (byte) (p[3]);
+                        byte t = (byte) (p[0]);
+                        if ((a) != 0)
+                        {
+                            byte half = (byte) (a/2);
+                            p[0] = (byte) ((p[2]*255 + half)/a);
+                            p[1] = (byte) ((p[1]*255 + half)/a);
+                            p[2] = (byte) ((t*255 + half)/a);
+                        }
+                        else
+                        {
+                            p[0] = (byte) (p[2]);
+                            p[2] = (byte) (t);
+                        }
+                        p += 4;
+                    }
+                }
+                else
+                {
+                    for (i = (uint) (0); (i) < (pixel_count); ++i)
+                    {
+                        byte t = (byte) (p[0]);
+                        p[0] = (byte) (p[2]);
+                        p[2] = (byte) (t);
+                        p += 4;
+                    }
+                }
+            }
+
+        }
+
+        public static int stbi__parse_png_file(stbi__png z, int scan, int req_comp)
+        {
+            byte* palette = stackalloc byte[1024];
+            byte pal_img_n = (byte) (0);
+            byte has_trans = (byte) (0);
+            byte* tc = stackalloc byte[3];
+            ushort* tc16 = stackalloc ushort[3];
+            uint ioff = (uint) (0);
+            uint idata_limit = (uint) (0);
+            uint i;
+            uint pal_len = (uint) (0);
+            int first = (int) (1);
+            int k;
+            int interlace = (int) (0);
+            int color = (int) (0);
+            int is_iphone = (int) (0);
+            stbi__context s = z.s;
+            z.expanded = (null);
+            z.idata = (null);
+            z._out_ = (null);
+            if (stbi__check_png_header(s) == 0) return (int) (0);
+            if ((scan) == (STBI__SCAN_type)) return (int) (1);
+            for (;;)
+            {
+                stbi__pngchunk c = (stbi__pngchunk) (stbi__get_chunk_header(s));
+                switch (c.type)
+                {
+                    case ((('C') << 24) + (('g') << 16) + (('B') << 8) + ('I')):
+                        is_iphone = (int) (1);
+                        stbi__skip(s, (int) (c.length));
+                        break;
+                    case ((('I') << 24) + (('H') << 16) + (('D') << 8) + ('R')):
+                    {
+                        int comp;
+                        int filter;
+                        if (first == 0) return (int) (stbi__err("multiple IHDR"));
+                        first = (int) (0);
+                        if (c.length != 13) return (int) (stbi__err("bad IHDR len"));
+                        s.img_x = (uint) (stbi__get32be(s));
+                        if ((s.img_x) > (1 << 24)) return (int) (stbi__err("too large"));
+                        s.img_y = (uint) (stbi__get32be(s));
+                        if ((s.img_y) > (1 << 24)) return (int) (stbi__err("too large"));
+                        z.depth = (int) (stbi__get8(s));
+                        if (((((z.depth != 1) && (z.depth != 2)) && (z.depth != 4)) && (z.depth != 8)) &&
+                            (z.depth != 16))
+                            return (int) (stbi__err("1/2/4/8/16-bit only"));
+                        color = (int) (stbi__get8(s));
+                        if ((color) > (6)) return (int) (stbi__err("bad ctype"));
+                        if (((color) == (3)) && ((z.depth) == (16))) return (int) (stbi__err("bad ctype"));
+                        if ((color) == (3)) pal_img_n = (byte) (3);
+                        else if ((color & 1) != 0) return (int) (stbi__err("bad ctype"));
+                        comp = (int) (stbi__get8(s));
+                        if ((comp) != 0) return (int) (stbi__err("bad comp method"));
+                        filter = (int) (stbi__get8(s));
+                        if ((filter) != 0) return (int) (stbi__err("bad filter method"));
+                        interlace = (int) (stbi__get8(s));
+                        if ((interlace) > (1)) return (int) (stbi__err("bad interlace method"));
+                        if ((s.img_x == 0) || (s.img_y == 0)) return (int) (stbi__err("0-pixel image"));
+                        if (pal_img_n == 0)
+                        {
+                            s.img_n = (int) (((color & 2) != 0 ? 3 : 1) + ((color & 4) != 0 ? 1 : 0));
+                            if (((1 << 30)/s.img_x/s.img_n) < (s.img_y)) return (int) (stbi__err("too large"));
+                            if ((scan) == (STBI__SCAN_header)) return (int) (1);
+                        }
+                        else
+                        {
+                            s.img_n = (int) (1);
+                            if (((1 << 30)/s.img_x/4) < (s.img_y)) return (int) (stbi__err("too large"));
+                        }
+                        break;
+                    }
+                    case ((('P') << 24) + (('L') << 16) + (('T') << 8) + ('E')):
+                    {
+                        if ((first) != 0) return (int) (stbi__err("first not IHDR"));
+                        if ((c.length) > (256*3)) return (int) (stbi__err("invalid PLTE"));
+                        pal_len = (uint) (c.length/3);
+                        if (pal_len*3 != c.length) return (int) (stbi__err("invalid PLTE"));
+                        for (i = (uint) (0); (i) < (pal_len); ++i)
+                        {
+                            palette[i*4 + 0] = (byte) (stbi__get8(s));
+                            palette[i*4 + 1] = (byte) (stbi__get8(s));
+                            palette[i*4 + 2] = (byte) (stbi__get8(s));
+                            palette[i*4 + 3] = (byte) (255);
+                        }
+                        break;
+                    }
+                    case ((('t') << 24) + (('R') << 16) + (('N') << 8) + ('S')):
+                    {
+                        if ((first) != 0) return (int) (stbi__err("first not IHDR"));
+                        if ((z.idata) != null) return (int) (stbi__err("tRNS after IDAT"));
+                        if ((pal_img_n) != 0)
+                        {
+                            if ((scan) == (STBI__SCAN_header))
+                            {
+                                s.img_n = (int) (4);
+                                return (int) (1);
+                            }
+                            if ((pal_len) == (0)) return (int) (stbi__err("tRNS before PLTE"));
+                            if ((c.length) > (pal_len)) return (int) (stbi__err("bad tRNS len"));
+                            pal_img_n = (byte) (4);
+                            for (i = (uint) (0); (i) < (c.length); ++i)
+                            {
+                                palette[i*4 + 3] = (byte) (stbi__get8(s));
+                            }
+                        }
+                        else
+                        {
+                            if ((s.img_n & 1) == 0) return (int) (stbi__err("tRNS with alpha"));
+                            if (c.length != (uint) (s.img_n)*2) return (int) (stbi__err("bad tRNS len"));
+                            has_trans = (byte) (1);
+                            if ((z.depth) == (16))
+                            {
+                                for (k = (int) (0); (k) < (s.img_n); ++k)
+                                {
+                                    tc16[k] = ((ushort) (stbi__get16be(s)));
+                                }
+                            }
+                            else
+                            {
+                                for (k = (int) (0); (k) < (s.img_n); ++k)
+                                {
+                                    tc[k] = (byte) ((byte) (stbi__get16be(s) & 255)*stbi__depth_scale_table[z.depth]);
+                                }
+                            }
+                        }
+                        break;
+                    }
+                    case ((('I') << 24) + (('D') << 16) + (('A') << 8) + ('T')):
+                    {
+                        if ((first) != 0) return (int) (stbi__err("first not IHDR"));
+                        if (((pal_img_n) != 0) && (pal_len == 0)) return (int) (stbi__err("no PLTE"));
+                        if ((scan) == (STBI__SCAN_header))
+                        {
+                            s.img_n = (int) (pal_img_n);
+                            return (int) (1);
+                        }
+                        if (((int) (ioff + c.length)) < ((int) (ioff))) return (int) (0);
+                        if ((ioff + c.length) > (idata_limit))
+                        {
+                            uint idata_limit_old = (uint) (idata_limit);
+                            byte* p;
+                            if ((idata_limit) == (0)) idata_limit = (uint) ((c.length) > (4096) ? c.length : 4096);
+                            while ((ioff + c.length) > (idata_limit))
+                            {
+                                idata_limit *= (uint) (2);
+                            }
+                            p = (byte*) (realloc(z.idata, (ulong) (idata_limit)));
+                            if ((p) == (null)) return (int) (stbi__err("outofmem"));
+                            z.idata = p;
+                        }
+                        if (stbi__getn(s, z.idata + ioff, (int) (c.length)) == 0) return (int) (stbi__err("outofdata"));
+                        ioff += (uint) (c.length);
+                        break;
+                    }
+                    case ((('I') << 24) + (('E') << 16) + (('N') << 8) + ('D')):
+                    {
+                        uint raw_len;
+                        uint bpl;
+                        if ((first) != 0) return (int) (stbi__err("first not IHDR"));
+                        if (scan != STBI__SCAN_load) return (int) (1);
+                        if ((z.idata) == (null)) return (int) (stbi__err("no IDAT"));
+                        bpl = (uint) ((s.img_x*z.depth + 7)/8);
+                        raw_len = (uint) (bpl*s.img_y*s.img_n + s.img_y);
+                        z.expanded =
+                            (byte*)
+                                (stbi_zlib_decode_malloc_guesssize_headerflag((sbyte*) (z.idata), (int) (ioff),
+                                    (int) (raw_len),
+                                    (int*) (&raw_len), is_iphone != 0 ? 0 : 1));
+                        if ((z.expanded) == (null)) return (int) (0);
+                        free(z.idata);
+                        z.idata = (null);
+                        if (((((req_comp) == (s.img_n + 1)) && (req_comp != 3)) && (pal_img_n == 0)) ||
+                            ((has_trans) != 0))
+                            s.img_out_n = (int) (s.img_n + 1);
+                        else s.img_out_n = (int) (s.img_n);
+                        if (
+                            stbi__create_png_image(z, z.expanded, (uint) (raw_len), (int) (s.img_out_n), (int) (z.depth),
+                                (int) (color),
+                                (int) (interlace)) == 0) return (int) (0);
+                        if ((has_trans) != 0)
+                        {
+                            if ((z.depth) == (16))
+                            {
+                                if (stbi__compute_transparency16(z, tc16, (int) (s.img_out_n)) == 0) return (int) (0);
+                            }
+                            else
+                            {
+                                if (stbi__compute_transparency(z, tc, (int) (s.img_out_n)) == 0) return (int) (0);
+                            }
+                        }
+                        if ((((is_iphone) != 0) && ((stbi__de_iphone_flag) != 0)) && ((s.img_out_n) > (2)))
+                            stbi__de_iphone(z);
+                        if ((pal_img_n) != 0)
+                        {
+                            s.img_n = (int) (pal_img_n);
+                            s.img_out_n = (int) (pal_img_n);
+                            if ((req_comp) >= (3)) s.img_out_n = (int) (req_comp);
+                            if (stbi__expand_png_palette(z, palette, (int) (pal_len), (int) (s.img_out_n)) == 0)
+                                return (int) (0);
+                        }
+                        else if ((has_trans) != 0)
+                        {
+                            ++s.img_n;
+                        }
+                        free(z.expanded);
+                        z.expanded = (null);
+                        return (int) (1);
+                    }
+                    default:
+                        if ((first) != 0) return (int) (stbi__err("first not IHDR"));
+                        if ((c.type & (1 << 29)) == (0))
+                        {
+                            string invalid_chunk = "XXXX PNG chunk not known";
+                            return (int) (stbi__err(invalid_chunk));
+                        }
+                        stbi__skip(s, (int) (c.length));
+                        break;
+                }
+                stbi__get32be(s);
+            }
+        }
+
+        public static void* stbi__do_png(stbi__png p, int* x, int* y, int* n, int req_comp, stbi__result_info* ri)
+        {
+            void* result = (null);
+            if (((req_comp) < (0)) || ((req_comp) > (4)))
+                return ((byte*) ((ulong) ((stbi__err("bad req_comp")) != 0 ? ((byte*) null) : (null))));
+            if ((stbi__parse_png_file(p, (int) (STBI__SCAN_load), (int) (req_comp))) != 0)
+            {
+                if ((p.depth) < (8)) ri->bits_per_channel = (int) (8);
+                else ri->bits_per_channel = (int) (p.depth);
+                result = p._out_;
+                p._out_ = (null);
+                if (((req_comp) != 0) && (req_comp != p.s.img_out_n))
+                {
+                    if ((ri->bits_per_channel) == (8))
+                        result = stbi__convert_format((byte*) (result), (int) (p.s.img_out_n), (int) (req_comp),
+                            (uint) (p.s.img_x),
+                            (uint) (p.s.img_y));
+                    else
+                        result = stbi__convert_format16((ushort*) (result), (int) (p.s.img_out_n), (int) (req_comp),
+                            (uint) (p.s.img_x),
+                            (uint) (p.s.img_y));
+                    p.s.img_out_n = (int) (req_comp);
+                    if ((result) == (null)) return result;
+                }
+                *x = (int) (p.s.img_x);
+                *y = (int) (p.s.img_y);
+                if ((n) != null) *n = (int) (p.s.img_n);
+            }
+
+            free(p._out_);
+            p._out_ = (null);
+            free(p.expanded);
+            p.expanded = (null);
+            free(p.idata);
+            p.idata = (null);
+            return result;
+        }
+
+        public static void* stbi__png_load(stbi__context s, int* x, int* y, int* comp, int req_comp,
+            stbi__result_info* ri)
+        {
+            stbi__png p = new stbi__png();
+            p.s = s;
+            return stbi__do_png(p, x, y, comp, (int) (req_comp), ri);
+        }
+
+        public static int stbi__png_test(stbi__context s)
+        {
+            int r;
+            r = (int) (stbi__check_png_header(s));
+            stbi__rewind(s);
+            return (int) (r);
+        }
+
+        public static int stbi__png_info_raw(stbi__png p, int* x, int* y, int* comp)
+        {
+            if (stbi__parse_png_file(p, (int) (STBI__SCAN_header), (int) (0)) == 0)
+            {
+                stbi__rewind(p.s);
+                return (int) (0);
+            }
+
+            if ((x) != null) *x = (int) (p.s.img_x);
+            if ((y) != null) *y = (int) (p.s.img_y);
+            if ((comp) != null) *comp = (int) (p.s.img_n);
+            return (int) (1);
+        }
+
+        public static int stbi__png_info(stbi__context s, int* x, int* y, int* comp)
+        {
+            stbi__png p = new stbi__png();
+            p.s = s;
+            return (int) (stbi__png_info_raw(p, x, y, comp));
+        }
+
+        public static int stbi__bmp_test_raw(stbi__context s)
+        {
+            int r;
+            int sz;
+            if (stbi__get8(s) != 'B') return (int) (0);
+            if (stbi__get8(s) != 'M') return (int) (0);
+            stbi__get32le(s);
+            stbi__get16le(s);
+            stbi__get16le(s);
+            stbi__get32le(s);
+            sz = (int) (stbi__get32le(s));
+            r =
+                (int)
+                    ((((((sz) == (12)) || ((sz) == (40))) || ((sz) == (56))) || ((sz) == (108))) || ((sz) == (124))
+                        ? 1
+                        : 0);
+            return (int) (r);
+        }
+
+        public static int stbi__bmp_test(stbi__context s)
+        {
+            int r = (int) (stbi__bmp_test_raw(s));
+            stbi__rewind(s);
+            return (int) (r);
+        }
+
+        public static int stbi__high_bit(uint z)
+        {
+            int n = (int) (0);
+            if ((z) == (0)) return (int) (-1);
+            if ((z) >= (0x10000))
+            {
+                n += (int) (16);
+                z >>= 16;
+            }
+
+            if ((z) >= (0x00100))
+            {
+                n += (int) (8);
+                z >>= 8;
+            }
+
+            if ((z) >= (0x00010))
+            {
+                n += (int) (4);
+                z >>= 4;
+            }
+
+            if ((z) >= (0x00004))
+            {
+                n += (int) (2);
+                z >>= 2;
+            }
+
+            if ((z) >= (0x00002))
+            {
+                n += (int) (1);
+                z >>= 1;
+            }
+
+            return (int) (n);
+        }
+
+        public static int stbi__bitcount(uint a)
+        {
+            a = (uint) ((a & 0x55555555) + ((a >> 1) & 0x55555555));
+            a = (uint) ((a & 0x33333333) + ((a >> 2) & 0x33333333));
+            a = (uint) ((a + (a >> 4)) & 0x0f0f0f0f);
+            a = (uint) (a + (a >> 8));
+            a = (uint) (a + (a >> 16));
+            return (int) (a & 0xff);
+        }
+
+        public static int stbi__shiftsigned(int v, int shift, int bits)
+        {
+            int result;
+            int z = (int) (0);
+            if ((shift) < (0)) v <<= -shift;
+            else v >>= shift;
+            result = (int) (v);
+            z = (int) (bits);
+            while ((z) < (8))
+            {
+                result += (int) (v >> z);
+                z += (int) (bits);
+            }
+            return (int) (result);
+        }
+
+        public static void* stbi__bmp_parse_header(stbi__context s, stbi__bmp_data* info)
+        {
+            int hsz;
+            if ((stbi__get8(s) != 'B') || (stbi__get8(s) != 'M'))
+                return ((byte*) ((ulong) ((stbi__err("not BMP")) != 0 ? ((byte*) null) : (null))));
+            stbi__get32le(s);
+            stbi__get16le(s);
+            stbi__get16le(s);
+            info->offset = (int) (stbi__get32le(s));
+            info->hsz = (int) (hsz = (int) (stbi__get32le(s)));
+            info->mr = (uint) (info->mg = (uint) (info->mb = (uint) (info->ma = (uint) (0))));
+            if (((((hsz != 12) && (hsz != 40)) && (hsz != 56)) && (hsz != 108)) && (hsz != 124))
+                return ((byte*) ((ulong) ((stbi__err("unknown BMP")) != 0 ? ((byte*) null) : (null))));
+            if ((hsz) == (12))
+            {
+                s.img_x = (uint) (stbi__get16le(s));
+                s.img_y = (uint) (stbi__get16le(s));
+            }
+            else
+            {
+                s.img_x = (uint) (stbi__get32le(s));
+                s.img_y = (uint) (stbi__get32le(s));
+            }
+
+            if (stbi__get16le(s) != 1)
+                return ((byte*) ((ulong) ((stbi__err("bad BMP")) != 0 ? ((byte*) null) : (null))));
+            info->bpp = (int) (stbi__get16le(s));
+            if ((info->bpp) == (1))
+                return ((byte*) ((ulong) ((stbi__err("monochrome")) != 0 ? ((byte*) null) : (null))));
+            if (hsz != 12)
+            {
+                int compress = (int) (stbi__get32le(s));
+                if (((compress) == (1)) || ((compress) == (2)))
+                    return ((byte*) ((ulong) ((stbi__err("BMP RLE")) != 0 ? ((byte*) null) : (null))));
+                stbi__get32le(s);
+                stbi__get32le(s);
+                stbi__get32le(s);
+                stbi__get32le(s);
+                stbi__get32le(s);
+                if (((hsz) == (40)) || ((hsz) == (56)))
+                {
+                    if ((hsz) == (56))
+                    {
+                        stbi__get32le(s);
+                        stbi__get32le(s);
+                        stbi__get32le(s);
+                        stbi__get32le(s);
+                    }
+                    if (((info->bpp) == (16)) || ((info->bpp) == (32)))
+                    {
+                        if ((compress) == (0))
+                        {
+                            if ((info->bpp) == (32))
+                            {
+                                info->mr = (uint) (0xffu << 16);
+                                info->mg = (uint) (0xffu << 8);
+                                info->mb = (uint) (0xffu << 0);
+                                info->ma = (uint) (0xffu << 24);
+                                info->all_a = (uint) (0);
+                            }
+                            else
+                            {
+                                info->mr = (uint) (31u << 10);
+                                info->mg = (uint) (31u << 5);
+                                info->mb = (uint) (31u << 0);
+                            }
+                        }
+                        else if ((compress) == (3))
+                        {
+                            info->mr = (uint) (stbi__get32le(s));
+                            info->mg = (uint) (stbi__get32le(s));
+                            info->mb = (uint) (stbi__get32le(s));
+                            if (((info->mr) == (info->mg)) && ((info->mg) == (info->mb)))
+                            {
+                                return ((byte*) ((ulong) ((stbi__err("bad BMP")) != 0 ? ((byte*) null) : (null))));
+                            }
+                        }
+                        else return ((byte*) ((ulong) ((stbi__err("bad BMP")) != 0 ? ((byte*) null) : (null))));
+                    }
+                }
+                else
+                {
+                    int i;
+                    if ((hsz != 108) && (hsz != 124))
+                        return ((byte*) ((ulong) ((stbi__err("bad BMP")) != 0 ? ((byte*) null) : (null))));
+                    info->mr = (uint) (stbi__get32le(s));
+                    info->mg = (uint) (stbi__get32le(s));
+                    info->mb = (uint) (stbi__get32le(s));
+                    info->ma = (uint) (stbi__get32le(s));
+                    stbi__get32le(s);
+                    for (i = (int) (0); (i) < (12); ++i)
+                    {
+                        stbi__get32le(s);
+                    }
+                    if ((hsz) == (124))
+                    {
+                        stbi__get32le(s);
+                        stbi__get32le(s);
+                        stbi__get32le(s);
+                        stbi__get32le(s);
+                    }
+                }
+            }
+
+            return (void*) (1);
+        }
+
+        public static void* stbi__bmp_load(stbi__context s, int* x, int* y, int* comp, int req_comp,
+            stbi__result_info* ri)
+        {
+            byte* _out_;
+            uint mr = (uint) (0);
+            uint mg = (uint) (0);
+            uint mb = (uint) (0);
+            uint ma = (uint) (0);
+            uint all_a;
+            byte* pal = stackalloc byte[256*4];
+            int psize = (int) (0);
+            int i;
+            int j;
+            int width;
+            int flip_vertically;
+            int pad;
+            int target;
+            stbi__bmp_data info = new stbi__bmp_data();
+            info.all_a = (uint) (255);
+            if ((stbi__bmp_parse_header(s, &info)) == (null)) return (null);
+            flip_vertically = (int) (((int) (s.img_y)) > (0) ? 1 : 0);
+            s.img_y = (uint) (abs((int) (s.img_y)));
+            mr = (uint) (info.mr);
+            mg = (uint) (info.mg);
+            mb = (uint) (info.mb);
+            ma = (uint) (info.ma);
+            all_a = (uint) (info.all_a);
+            if ((info.hsz) == (12))
+            {
+                if ((info.bpp) < (24)) psize = (int) ((info.offset - 14 - 24)/3);
+            }
+            else
+            {
+                if ((info.bpp) < (16)) psize = (int) ((info.offset - 14 - info.hsz) >> 2);
+            }
+
+            s.img_n = (int) ((ma) != 0 ? 4 : 3);
+            if (((req_comp) != 0) && ((req_comp) >= (3))) target = (int) (req_comp);
+            else target = (int) (s.img_n);
+            if (stbi__mad3sizes_valid((int) (target), (int) (s.img_x), (int) (s.img_y), (int) (0)) == 0)
+                return ((byte*) ((ulong) ((stbi__err("too large")) != 0 ? ((byte*) null) : (null))));
+            _out_ = (byte*) (stbi__malloc_mad3((int) (target), (int) (s.img_x), (int) (s.img_y), (int) (0)));
+            if (_out_ == null) return ((byte*) ((ulong) ((stbi__err("outofmem")) != 0 ? ((byte*) null) : (null))));
+            if ((info.bpp) < (16))
+            {
+                int z = (int) (0);
+                if (((psize) == (0)) || ((psize) > (256)))
+                {
+                    free(_out_);
+                    return ((byte*) ((ulong) ((stbi__err("invalid")) != 0 ? ((byte*) null) : (null))));
+                }
+                for (i = (int) (0); (i) < (psize); ++i)
+                {
+                    pal[i*4 + 2] = (byte) (stbi__get8(s));
+                    pal[i*4 + 1] = (byte) (stbi__get8(s));
+                    pal[i*4 + 0] = (byte) (stbi__get8(s));
+                    if (info.hsz != 12) stbi__get8(s);
+                    pal[i*4 + 3] = (byte) (255);
+                }
+                stbi__skip(s, (int) (info.offset - 14 - info.hsz - psize*((info.hsz) == (12) ? 3 : 4)));
+                if ((info.bpp) == (4)) width = (int) ((s.img_x + 1) >> 1);
+                else if ((info.bpp) == (8)) width = (int) (s.img_x);
+                else
+                {
+                    free(_out_);
+                    return ((byte*) ((ulong) ((stbi__err("bad bpp")) != 0 ? ((byte*) null) : (null))));
+                }
+                pad = (int) ((-width) & 3);
+                for (j = (int) (0); (j) < ((int) (s.img_y)); ++j)
+                {
+                    for (i = (int) (0); (i) < ((int) (s.img_x)); i += (int) (2))
+                    {
+                        int v = (int) (stbi__get8(s));
+                        int v2 = (int) (0);
+                        if ((info.bpp) == (4))
+                        {
+                            v2 = (int) (v & 15);
+                            v >>= 4;
+                        }
+                        _out_[z++] = (byte) (pal[v*4 + 0]);
+                        _out_[z++] = (byte) (pal[v*4 + 1]);
+                        _out_[z++] = (byte) (pal[v*4 + 2]);
+                        if ((target) == (4)) _out_[z++] = (byte) (255);
+                        if ((i + 1) == ((int) (s.img_x))) break;
+                        v = (int) (((info.bpp) == (8)) ? stbi__get8(s) : v2);
+                        _out_[z++] = (byte) (pal[v*4 + 0]);
+                        _out_[z++] = (byte) (pal[v*4 + 1]);
+                        _out_[z++] = (byte) (pal[v*4 + 2]);
+                        if ((target) == (4)) _out_[z++] = (byte) (255);
+                    }
+                    stbi__skip(s, (int) (pad));
+                }
+            }
+            else
+            {
+                int rshift = (int) (0);
+                int gshift = (int) (0);
+                int bshift = (int) (0);
+                int ashift = (int) (0);
+                int rcount = (int) (0);
+                int gcount = (int) (0);
+                int bcount = (int) (0);
+                int acount = (int) (0);
+                int z = (int) (0);
+                int easy = (int) (0);
+                stbi__skip(s, (int) (info.offset - 14 - info.hsz));
+                if ((info.bpp) == (24)) width = (int) (3*s.img_x);
+                else if ((info.bpp) == (16)) width = (int) (2*s.img_x);
+                else width = (int) (0);
+                pad = (int) ((-width) & 3);
+                if ((info.bpp) == (24))
+                {
+                    easy = (int) (1);
+                }
+                else if ((info.bpp) == (32))
+                {
+                    if (((((mb) == (0xff)) && ((mg) == (0xff00))) && ((mr) == (0x00ff0000))) && ((ma) == (0xff000000)))
+                        easy = (int) (2);
+                }
+                if (easy == 0)
+                {
+                    if (((mr == 0) || (mg == 0)) || (mb == 0))
+                    {
+                        free(_out_);
+                        return ((byte*) ((ulong) ((stbi__err("bad masks")) != 0 ? ((byte*) null) : (null))));
+                    }
+                    rshift = (int) (stbi__high_bit((uint) (mr)) - 7);
+                    rcount = (int) (stbi__bitcount((uint) (mr)));
+                    gshift = (int) (stbi__high_bit((uint) (mg)) - 7);
+                    gcount = (int) (stbi__bitcount((uint) (mg)));
+                    bshift = (int) (stbi__high_bit((uint) (mb)) - 7);
+                    bcount = (int) (stbi__bitcount((uint) (mb)));
+                    ashift = (int) (stbi__high_bit((uint) (ma)) - 7);
+                    acount = (int) (stbi__bitcount((uint) (ma)));
+                }
+                for (j = (int) (0); (j) < ((int) (s.img_y)); ++j)
+                {
+                    if ((easy) != 0)
+                    {
+                        for (i = (int) (0); (i) < ((int) (s.img_x)); ++i)
+                        {
+                            byte a;
+                            _out_[z + 2] = (byte) (stbi__get8(s));
+                            _out_[z + 1] = (byte) (stbi__get8(s));
+                            _out_[z + 0] = (byte) (stbi__get8(s));
+                            z += (int) (3);
+                            a = (byte) ((easy) == (2) ? stbi__get8(s) : 255);
+                            all_a |= (uint) (a);
+                            if ((target) == (4)) _out_[z++] = (byte) (a);
+                        }
+                    }
+                    else
+                    {
+                        int bpp = (int) (info.bpp);
+                        for (i = (int) (0); (i) < ((int) (s.img_x)); ++i)
+                        {
+                            uint v = (uint) ((bpp) == (16) ? (uint) (stbi__get16le(s)) : stbi__get32le(s));
+                            int a;
+                            _out_[z++] =
+                                ((byte) ((stbi__shiftsigned((int) (v & mr), (int) (rshift), (int) (rcount))) & 255));
+                            _out_[z++] =
+                                ((byte) ((stbi__shiftsigned((int) (v & mg), (int) (gshift), (int) (gcount))) & 255));
+                            _out_[z++] =
+                                ((byte) ((stbi__shiftsigned((int) (v & mb), (int) (bshift), (int) (bcount))) & 255));
+                            a =
+                                (int)
+                                    ((ma) != 0 ? stbi__shiftsigned((int) (v & ma), (int) (ashift), (int) (acount)) : 255);
+                            all_a |= (uint) (a);
+                            if ((target) == (4)) _out_[z++] = ((byte) ((a) & 255));
+                        }
+                    }
+                    stbi__skip(s, (int) (pad));
+                }
+            }
+
+            if (((target) == (4)) && ((all_a) == (0)))
+                for (i = (int) (4*s.img_x*s.img_y - 1); (i) >= (0); i -= (int) (4))
+                {
+                    _out_[i] = (byte) (255);
+                }
+            if ((flip_vertically) != 0)
+            {
+                byte t;
+                for (j = (int) (0); (j) < ((int) (s.img_y) >> 1); ++j)
+                {
+                    byte* p1 = _out_ + j*s.img_x*target;
+                    byte* p2 = _out_ + (s.img_y - 1 - j)*s.img_x*target;
+                    for (i = (int) (0); (i) < ((int) (s.img_x)*target); ++i)
+                    {
+                        t = (byte) (p1[i]);
+                        p1[i] = (byte) (p2[i]);
+                        p2[i] = (byte) (t);
+                    }
+                }
+            }
+
+            if (((req_comp) != 0) && (req_comp != target))
+            {
+                _out_ = stbi__convert_format(_out_, (int) (target), (int) (req_comp), (uint) (s.img_x), (uint) (s.img_y));
+                if ((_out_) == (null)) return _out_;
+            }
+
+            *x = (int) (s.img_x);
+            *y = (int) (s.img_y);
+            if ((comp) != null) *comp = (int) (s.img_n);
+            return _out_;
+        }
+
+        public static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16)
+        {
+            if ((is_rgb16) != null) *is_rgb16 = (int) (0);
+            switch (bits_per_pixel)
+            {
+                case 8:
+                    return (int) (STBI_grey);
+                case 15:
+                case 16:
+                    if (((bits_per_pixel) == (16)) && ((is_grey) != 0)) return (int) (STBI_grey_alpha);
+                    if ((is_rgb16) != null) *is_rgb16 = (int) (1);
+                    return (int) (STBI_rgb);
+                case 24:
+                case 32:
+                    return (int) (bits_per_pixel/8);
+                default:
+                    return (int) (0);
+            }
+
+        }
+
+        public static int stbi__tga_info(stbi__context s, int* x, int* y, int* comp)
+        {
+            int tga_w;
+            int tga_h;
+            int tga_comp;
+            int tga_image_type;
+            int tga_bits_per_pixel;
+            int tga_colormap_bpp;
+            int sz;
+            int tga_colormap_type;
+            stbi__get8(s);
+            tga_colormap_type = (int) (stbi__get8(s));
+            if ((tga_colormap_type) > (1))
+            {
+                stbi__rewind(s);
+                return (int) (0);
+            }
+
+            tga_image_type = (int) (stbi__get8(s));
+            if ((tga_colormap_type) == (1))
+            {
+                if ((tga_image_type != 1) && (tga_image_type != 9))
+                {
+                    stbi__rewind(s);
+                    return (int) (0);
+                }
+                stbi__skip(s, (int) (4));
+                sz = (int) (stbi__get8(s));
+                if (((((sz != 8) && (sz != 15)) && (sz != 16)) && (sz != 24)) && (sz != 32))
+                {
+                    stbi__rewind(s);
+                    return (int) (0);
+                }
+                stbi__skip(s, (int) (4));
+                tga_colormap_bpp = (int) (sz);
+            }
+            else
+            {
+                if ((((tga_image_type != 2) && (tga_image_type != 3)) && (tga_image_type != 10)) &&
+                    (tga_image_type != 11))
+                {
+                    stbi__rewind(s);
+                    return (int) (0);
+                }
+                stbi__skip(s, (int) (9));
+                tga_colormap_bpp = (int) (0);
+            }
+
+            tga_w = (int) (stbi__get16le(s));
+            if ((tga_w) < (1))
+            {
+                stbi__rewind(s);
+                return (int) (0);
+            }
+
+            tga_h = (int) (stbi__get16le(s));
+            if ((tga_h) < (1))
+            {
+                stbi__rewind(s);
+                return (int) (0);
+            }
+
+            tga_bits_per_pixel = (int) (stbi__get8(s));
+            stbi__get8(s);
+            if (tga_colormap_bpp != 0)
+            {
+                if ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16))
+                {
+                    stbi__rewind(s);
+                    return (int) (0);
+                }
+                tga_comp = (int) (stbi__tga_get_comp((int) (tga_colormap_bpp), (int) (0), (null)));
+            }
+            else
+            {
+                tga_comp =
+                    (int)
+                        (stbi__tga_get_comp((int) (tga_bits_per_pixel),
+                            (((tga_image_type) == (3))) || (((tga_image_type) == (11))) ? 1 : 0, (null)));
+            }
+
+            if (tga_comp == 0)
+            {
+                stbi__rewind(s);
+                return (int) (0);
+            }
+
+            if ((x) != null) *x = (int) (tga_w);
+            if ((y) != null) *y = (int) (tga_h);
+            if ((comp) != null) *comp = (int) (tga_comp);
+            return (int) (1);
+        }
+
+        public static int stbi__tga_test(stbi__context s)
+        {
+            int res = (int) (0);
+            int sz;
+            int tga_color_type;
+            stbi__get8(s);
+            tga_color_type = (int) (stbi__get8(s));
+            if ((tga_color_type) > (1)) goto errorEnd;
+            sz = (int) (stbi__get8(s));
+            if ((tga_color_type) == (1))
+            {
+                if ((sz != 1) && (sz != 9)) goto errorEnd;
+                stbi__skip(s, (int) (4));
+                sz = (int) (stbi__get8(s));
+                if (((((sz != 8) && (sz != 15)) && (sz != 16)) && (sz != 24)) && (sz != 32)) goto errorEnd;
+                stbi__skip(s, (int) (4));
+            }
+            else
+            {
+                if ((((sz != 2) && (sz != 3)) && (sz != 10)) && (sz != 11)) goto errorEnd;
+                stbi__skip(s, (int) (9));
+            }
+
+            if ((stbi__get16le(s)) < (1)) goto errorEnd;
+            if ((stbi__get16le(s)) < (1)) goto errorEnd;
+            sz = (int) (stbi__get8(s));
+            if ((((tga_color_type) == (1)) && (sz != 8)) && (sz != 16)) goto errorEnd;
+            if (((((sz != 8) && (sz != 15)) && (sz != 16)) && (sz != 24)) && (sz != 32)) goto errorEnd;
+            res = (int) (1);
+            errorEnd:
+            ;
+            stbi__rewind(s);
+            return (int) (res);
+        }
+
+        public static void stbi__tga_read_rgb16(stbi__context s, byte* _out_)
+        {
+            ushort px = (ushort) (stbi__get16le(s));
+            ushort fiveBitMask = (ushort) (31);
+            int r = (int) ((px >> 10) & fiveBitMask);
+            int g = (int) ((px >> 5) & fiveBitMask);
+            int b = (int) (px & fiveBitMask);
+            _out_[0] = ((byte) ((r*255)/31));
+            _out_[1] = ((byte) ((g*255)/31));
+            _out_[2] = ((byte) ((b*255)/31));
+        }
+
+        public static void* stbi__tga_load(stbi__context s, int* x, int* y, int* comp, int req_comp,
+            stbi__result_info* ri)
+        {
+            int tga_offset = (int) (stbi__get8(s));
+            int tga_indexed = (int) (stbi__get8(s));
+            int tga_image_type = (int) (stbi__get8(s));
+            int tga_is_RLE = (int) (0);
+            int tga_palette_start = (int) (stbi__get16le(s));
+            int tga_palette_len = (int) (stbi__get16le(s));
+            int tga_palette_bits = (int) (stbi__get8(s));
+            int tga_x_origin = (int) (stbi__get16le(s));
+            int tga_y_origin = (int) (stbi__get16le(s));
+            int tga_width = (int) (stbi__get16le(s));
+            int tga_height = (int) (stbi__get16le(s));
+            int tga_bits_per_pixel = (int) (stbi__get8(s));
+            int tga_comp;
+            int tga_rgb16 = (int) (0);
+            int tga_inverted = (int) (stbi__get8(s));
+            byte* tga_data;
+            byte* tga_palette = (null);
+            int i;
+            int j;
+            byte* raw_data = stackalloc byte[4];
+            raw_data[0] = (byte) (0);
+
+            int RLE_count = (int) (0);
+            int RLE_repeating = (int) (0);
+            int read_next_pixel = (int) (1);
+            if ((tga_image_type) >= (8))
+            {
+                tga_image_type -= (int) (8);
+                tga_is_RLE = (int) (1);
+            }
+
+            tga_inverted = (int) (1 - ((tga_inverted >> 5) & 1));
+            if ((tga_indexed) != 0)
+                tga_comp = (int) (stbi__tga_get_comp((int) (tga_palette_bits), (int) (0), &tga_rgb16));
+            else
+                tga_comp =
+                    (int) (stbi__tga_get_comp((int) (tga_bits_per_pixel), (tga_image_type) == (3) ? 1 : 0, &tga_rgb16));
+            if (tga_comp == 0) return ((byte*) ((ulong) ((stbi__err("bad format")) != 0 ? ((byte*) null) : (null))));
+            *x = (int) (tga_width);
+            *y = (int) (tga_height);
+            if ((comp) != null) *comp = (int) (tga_comp);
+            if (stbi__mad3sizes_valid((int) (tga_width), (int) (tga_height), (int) (tga_comp), (int) (0)) == 0)
+                return ((byte*) ((ulong) ((stbi__err("too large")) != 0 ? ((byte*) null) : (null))));
+            tga_data = (byte*) (stbi__malloc_mad3((int) (tga_width), (int) (tga_height), (int) (tga_comp), (int) (0)));
+            if (tga_data == null) return ((byte*) ((ulong) ((stbi__err("outofmem")) != 0 ? ((byte*) null) : (null))));
+            stbi__skip(s, (int) (tga_offset));
+            if (((tga_indexed == 0) && (tga_is_RLE == 0)) && (tga_rgb16 == 0))
+            {
+                for (i = (int) (0); (i) < (tga_height); ++i)
+                {
+                    int row = (int) ((tga_inverted) != 0 ? tga_height - i - 1 : i);
+                    byte* tga_row = tga_data + row*tga_width*tga_comp;
+                    stbi__getn(s, tga_row, (int) (tga_width*tga_comp));
+                }
+            }
+            else
+            {
+                if ((tga_indexed) != 0)
+                {
+                    stbi__skip(s, (int) (tga_palette_start));
+                    tga_palette = (byte*) (stbi__malloc_mad2((int) (tga_palette_len), (int) (tga_comp), (int) (0)));
+                    if (tga_palette == null)
+                    {
+                        free(tga_data);
+                        return ((byte*) ((ulong) ((stbi__err("outofmem")) != 0 ? ((byte*) null) : (null))));
+                    }
+                    if ((tga_rgb16) != 0)
+                    {
+                        byte* pal_entry = tga_palette;
+                        for (i = (int) (0); (i) < (tga_palette_len); ++i)
+                        {
+                            stbi__tga_read_rgb16(s, pal_entry);
+                            pal_entry += tga_comp;
+                        }
+                    }
+                    else if (stbi__getn(s, tga_palette, (int) (tga_palette_len*tga_comp)) == 0)
+                    {
+                        free(tga_data);
+                        free(tga_palette);
+                        return ((byte*) ((ulong) ((stbi__err("bad palette")) != 0 ? ((byte*) null) : (null))));
+                    }
+                }
+                for (i = (int) (0); (i) < (tga_width*tga_height); ++i)
+                {
+                    if ((tga_is_RLE) != 0)
+                    {
+                        if ((RLE_count) == (0))
+                        {
+                            int RLE_cmd = (int) (stbi__get8(s));
+                            RLE_count = (int) (1 + (RLE_cmd & 127));
+                            RLE_repeating = (int) (RLE_cmd >> 7);
+                            read_next_pixel = (int) (1);
+                        }
+                        else if (RLE_repeating == 0)
+                        {
+                            read_next_pixel = (int) (1);
+                        }
+                    }
+                    else
+                    {
+                        read_next_pixel = (int) (1);
+                    }
+                    if ((read_next_pixel) != 0)
+                    {
+                        if ((tga_indexed) != 0)
+                        {
+                            int pal_idx = (int) (((tga_bits_per_pixel) == (8)) ? stbi__get8(s) : stbi__get16le(s));
+                            if ((pal_idx) >= (tga_palette_len))
+                            {
+                                pal_idx = (int) (0);
+                            }
+                            pal_idx *= (int) (tga_comp);
+                            for (j = (int) (0); (j) < (tga_comp); ++j)
+                            {
+                                raw_data[j] = (byte) (tga_palette[pal_idx + j]);
+                            }
+                        }
+                        else if ((tga_rgb16) != 0)
+                        {
+                            stbi__tga_read_rgb16(s, raw_data);
+                        }
+                        else
+                        {
+                            for (j = (int) (0); (j) < (tga_comp); ++j)
+                            {
+                                raw_data[j] = (byte) (stbi__get8(s));
+                            }
+                        }
+                        read_next_pixel = (int) (0);
+                    }
+                    for (j = (int) (0); (j) < (tga_comp); ++j)
+                    {
+                        tga_data[i*tga_comp + j] = (byte) (raw_data[j]);
+                    }
+                    --RLE_count;
+                }
+                if ((tga_inverted) != 0)
+                {
+                    for (j = (int) (0); (j*2) < (tga_height); ++j)
+                    {
+                        int index1 = (int) (j*tga_width*tga_comp);
+                        int index2 = (int) ((tga_height - 1 - j)*tga_width*tga_comp);
+                        for (i = (int) (tga_width*tga_comp); (i) > (0); --i)
+                        {
+                            byte temp = (byte) (tga_data[index1]);
+                            tga_data[index1] = (byte) (tga_data[index2]);
+                            tga_data[index2] = (byte) (temp);
+                            ++index1;
+                            ++index2;
+                        }
+                    }
+                }
+                if (tga_palette != (null))
+                {
+                    free(tga_palette);
+                }
+            }
+
+            if (((tga_comp) >= (3)) && (tga_rgb16 == 0))
+            {
+                byte* tga_pixel = tga_data;
+                for (i = (int) (0); (i) < (tga_width*tga_height); ++i)
+                {
+                    byte temp = (byte) (tga_pixel[0]);
+                    tga_pixel[0] = (byte) (tga_pixel[2]);
+                    tga_pixel[2] = (byte) (temp);
+                    tga_pixel += tga_comp;
+                }
+            }
+
+            if (((req_comp) != 0) && (req_comp != tga_comp))
+                tga_data = stbi__convert_format(tga_data, (int) (tga_comp), (int) (req_comp), (uint) (tga_width),
+                    (uint) (tga_height));
+            tga_palette_start =
+                (int)
+                    (tga_palette_len =
+                        (int) (tga_palette_bits = (int) (tga_x_origin = (int) (tga_y_origin = (int) (0)))));
+            return tga_data;
+        }
+
+        public static int stbi__gif_test_raw(stbi__context s)
+        {
+            int sz;
+            if ((((stbi__get8(s) != 'G') || (stbi__get8(s) != 'I')) || (stbi__get8(s) != 'F')) || (stbi__get8(s) != '8'))
+                return (int) (0);
+            sz = (int) (stbi__get8(s));
+            if ((sz != '9') && (sz != '7')) return (int) (0);
+            if (stbi__get8(s) != 'a') return (int) (0);
+            return (int) (1);
+        }
+
+        public static int stbi__gif_test(stbi__context s)
+        {
+            int r = (int) (stbi__gif_test_raw(s));
+            stbi__rewind(s);
+            return (int) (r);
+        }
+
+        public static int stbi__gif_header(stbi__context s, stbi__gif g, int* comp, int is_info)
+        {
+            byte version;
+            if ((((stbi__get8(s) != 'G') || (stbi__get8(s) != 'I')) || (stbi__get8(s) != 'F')) || (stbi__get8(s) != '8'))
+                return (int) (stbi__err("not GIF"));
+            version = (byte) (stbi__get8(s));
+            if ((version != '7') && (version != '9')) return (int) (stbi__err("not GIF"));
+            if (stbi__get8(s) != 'a') return (int) (stbi__err("not GIF"));
+            stbi__g_failure_reason = "";
+            g.w = (int) (stbi__get16le(s));
+            g.h = (int) (stbi__get16le(s));
+            g.flags = (int) (stbi__get8(s));
+            g.bgindex = (int) (stbi__get8(s));
+            g.ratio = (int) (stbi__get8(s));
+            g.transparent = (int) (-1);
+            if (comp != null) *comp = (int) (4);
+            if ((is_info) != 0) return (int) (1);
+            if ((g.flags & 0x80) != 0) stbi__gif_parse_colortable(s, g.pal, (int) (2 << (g.flags & 7)), (int) (-1));
+            return (int) (1);
+        }
+
+        public static int stbi__gif_info_raw(stbi__context s, int* x, int* y, int* comp)
+        {
+            stbi__gif g = new stbi__gif();
+            if (stbi__gif_header(s, g, comp, (int) (1)) == 0)
+            {
+                stbi__rewind(s);
+                return (int) (0);
+            }
+
+            if ((x) != null) *x = (int) (g.w);
+            if ((y) != null) *y = (int) (g.h);
+
+            return (int) (1);
+        }
+
+        public static void stbi__out_gif_code(stbi__gif g, ushort code)
+        {
+            byte* p;
+            byte* c;
+            if ((g.codes[code].prefix) >= (0)) stbi__out_gif_code(g, (ushort) (g.codes[code].prefix));
+            if ((g.cur_y) >= (g.max_y)) return;
+            p = &g._out_[g.cur_x + g.cur_y];
+            c = &g.color_table[g.codes[code].suffix*4];
+            if ((c[3]) >= (128))
+            {
+                p[0] = (byte) (c[2]);
+                p[1] = (byte) (c[1]);
+                p[2] = (byte) (c[0]);
+                p[3] = (byte) (c[3]);
+            }
+
+            g.cur_x += (int) (4);
+            if ((g.cur_x) >= (g.max_x))
+            {
+                g.cur_x = (int) (g.start_x);
+                g.cur_y += (int) (g.step);
+                while (((g.cur_y) >= (g.max_y)) && ((g.parse) > (0)))
+                {
+                    g.step = (int) ((1 << g.parse)*g.line_size);
+                    g.cur_y = (int) (g.start_y + (g.step >> 1));
+                    --g.parse;
+                }
+            }
+
+        }
+
+        public static byte* stbi__process_gif_raster(stbi__context s, stbi__gif g)
+        {
+            byte lzw_cs;
+            int len;
+            int init_code;
+            uint first;
+            int codesize;
+            int codemask;
+            int avail;
+            int oldcode;
+            int bits;
+            int valid_bits;
+            int clear;
+            stbi__gif_lzw* p;
+            lzw_cs = (byte) (stbi__get8(s));
+            if ((lzw_cs) > (12)) return (null);
+            clear = (int) (1 << lzw_cs);
+            first = (uint) (1);
+            codesize = (int) (lzw_cs + 1);
+            codemask = (int) ((1 << codesize) - 1);
+            bits = (int) (0);
+            valid_bits = (int) (0);
+            for (init_code = (int) (0); (init_code) < (clear); init_code++)
+            {
+                ((stbi__gif_lzw*) (g.codes))[init_code].prefix = (short) (-1);
+                ((stbi__gif_lzw*) (g.codes))[init_code].first = ((byte) (init_code));
+                ((stbi__gif_lzw*) (g.codes))[init_code].suffix = ((byte) (init_code));
+            }
+            avail = (int) (clear + 2);
+            oldcode = (int) (-1);
+            len = (int) (0);
+            for (;;)
+            {
+                if ((valid_bits) < (codesize))
+                {
+                    if ((len) == (0))
+                    {
+                        len = (int) (stbi__get8(s));
+                        if ((len) == (0)) return g._out_;
+                    }
+                    --len;
+                    bits |= (int) ((int) (stbi__get8(s)) << valid_bits);
+                    valid_bits += (int) (8);
+                }
+                else
+                {
+                    int code = (int) (bits & codemask);
+                    bits >>= codesize;
+                    valid_bits -= (int) (codesize);
+                    if ((code) == (clear))
+                    {
+                        codesize = (int) (lzw_cs + 1);
+                        codemask = (int) ((1 << codesize) - 1);
+                        avail = (int) (clear + 2);
+                        oldcode = (int) (-1);
+                        first = (uint) (0);
+                    }
+                    else if ((code) == (clear + 1))
+                    {
+                        stbi__skip(s, (int) (len));
+                        while ((len = (int) (stbi__get8(s))) > (0))
+                        {
+                            stbi__skip(s, (int) (len));
+                        }
+                        return g._out_;
+                    }
+                    else if (code <= avail)
+                    {
+                        if ((first) != 0)
+                            return ((byte*) ((ulong) ((stbi__err("no clear code")) != 0 ? ((byte*) null) : (null))));
+                        if ((oldcode) >= (0))
+                        {
+                            p = (stbi__gif_lzw*) g.codes + avail++;
+                            if ((avail) > (4096))
+                                return
+                                    ((byte*) ((ulong) ((stbi__err("too many codes")) != 0 ? ((byte*) null) : (null))));
+                            p->prefix = ((short) (oldcode));
+                            p->first = (byte) (g.codes[oldcode].first);
+                            p->suffix = (byte) (((code) == (avail)) ? p->first : g.codes[code].first);
+                        }
+                        else if ((code) == (avail))
+                            return
+                                ((byte*)
+                                    ((ulong) ((stbi__err("illegal code in raster")) != 0 ? ((byte*) null) : (null))));
+                        stbi__out_gif_code(g, (ushort) (code));
+                        if (((avail & codemask) == (0)) && (avail <= 0x0FFF))
+                        {
+                            codesize++;
+                            codemask = (int) ((1 << codesize) - 1);
+                        }
+                        oldcode = (int) (code);
+                    }
+                    else
+                    {
+                        return
+                            ((byte*) ((ulong) ((stbi__err("illegal code in raster")) != 0 ? ((byte*) null) : (null))));
+                    }
+                }
+            }
+        }
+
+        public static void stbi__fill_gif_background(stbi__gif g, int x0, int y0, int x1, int y1)
+        {
+            int x;
+            int y;
+            byte* c = (byte*) g.pal + g.bgindex;
+            for (y = (int) (y0); (y) < (y1); y += (int) (4*g.w))
+            {
+                for (x = (int) (x0); (x) < (x1); x += (int) (4))
+                {
+                    byte* p = &g._out_[y + x];
+                    p[0] = (byte) (c[2]);
+                    p[1] = (byte) (c[1]);
+                    p[2] = (byte) (c[0]);
+                    p[3] = (byte) (0);
+                }
+            }
+        }
+
+        public static byte* stbi__gif_load_next(stbi__context s, stbi__gif g, int* comp, int req_comp)
+        {
+            int i;
+            byte* prev_out = null;
+            if (((g._out_) == null) && (stbi__gif_header(s, g, comp, (int) (0)) == 0)) return null;
+            if (stbi__mad3sizes_valid((int) (g.w), (int) (g.h), (int) (4), (int) (0)) == 0)
+                return ((byte*) ((ulong) ((stbi__err("too large")) != 0 ? ((byte*) null) : (null))));
+            prev_out = g._out_;
+            g._out_ = (byte*) (stbi__malloc_mad3((int) (4), (int) (g.w), (int) (g.h), (int) (0)));
+            if ((g._out_) == null) return ((byte*) ((ulong) ((stbi__err("outofmem")) != 0 ? ((byte*) null) : (null))));
+            switch ((g.eflags & 0x1C) >> 2)
+            {
+                case 0:
+                    stbi__fill_gif_background(g, (int) (0), (int) (0), (int) (4*g.w), (int) (4*g.w*g.h));
+                    break;
+                case 1:
+                    if ((prev_out) != null) memcpy(g._out_, prev_out, (ulong) (4*g.w*g.h));
+                    g.old_out = prev_out;
+                    break;
+                case 2:
+                    if ((prev_out) != null) memcpy(g._out_, prev_out, (ulong) (4*g.w*g.h));
+                    stbi__fill_gif_background(g, (int) (g.start_x), (int) (g.start_y), (int) (g.max_x), (int) (g.max_y));
+                    break;
+                case 3:
+                    if ((g.old_out) != null)
+                    {
+                        for (i = (int) (g.start_y); (i) < (g.max_y); i += (int) (4*g.w))
+                        {
+                            memcpy(&g._out_[i + g.start_x], &g.old_out[i + g.start_x], (ulong) (g.max_x - g.start_x));
+                        }
+                    }
+                    break;
+            }
+
+            for (;;)
+            {
+                switch (stbi__get8(s))
+                {
+                    case 0x2C:
+                    {
+                        int prev_trans = (int) (-1);
+                        int x;
+                        int y;
+                        int w;
+                        int h;
+                        byte* o;
+                        x = (int) (stbi__get16le(s));
+                        y = (int) (stbi__get16le(s));
+                        w = (int) (stbi__get16le(s));
+                        h = (int) (stbi__get16le(s));
+                        if (((x + w) > (g.w)) || ((y + h) > (g.h)))
+                            return
+                                ((byte*) ((ulong) ((stbi__err("bad Image Descriptor")) != 0 ? ((byte*) null) : (null))));
+                        g.line_size = (int) (g.w*4);
+                        g.start_x = (int) (x*4);
+                        g.start_y = (int) (y*g.line_size);
+                        g.max_x = (int) (g.start_x + w*4);
+                        g.max_y = (int) (g.start_y + h*g.line_size);
+                        g.cur_x = (int) (g.start_x);
+                        g.cur_y = (int) (g.start_y);
+                        g.lflags = (int) (stbi__get8(s));
+                        if ((g.lflags & 0x40) != 0)
+                        {
+                            g.step = (int) (8*g.line_size);
+                            g.parse = (int) (3);
+                        }
+                        else
+                        {
+                            g.step = (int) (g.line_size);
+                            g.parse = (int) (0);
+                        }
+                        if ((g.lflags & 0x80) != 0)
+                        {
+                            stbi__gif_parse_colortable(s, g.lpal, (int) (2 << (g.lflags & 7)),
+                                (int) ((g.eflags & 0x01) != 0 ? g.transparent : -1));
+                            g.color_table = (byte*) (g.lpal);
+                        }
+                        else if ((g.flags & 0x80) != 0)
+                        {
+                            if (((g.transparent) >= (0)) && (g.eflags & 0x01) != 0)
+                            {
+                                prev_trans = (int) (g.pal[g.transparent*4 + 3]);
+                                g.pal[g.transparent*4 + 3] = (byte) (0);
+                            }
+                            g.color_table = (byte*) (g.pal);
+                        }
+                        else
+                            return
+                                ((byte*) ((ulong) ((stbi__err("missing color table")) != 0 ? ((byte*) null) : (null))));
+                        o = stbi__process_gif_raster(s, g);
+                        if ((o) == (null)) return (null);
+                        if (prev_trans != -1) g.pal[g.transparent*4 + 3] = ((byte) (prev_trans));
+                        return o;
+                    }
+                    case 0x21:
+                    {
+                        int len;
+                        if ((stbi__get8(s)) == (0xF9))
+                        {
+                            len = (int) (stbi__get8(s));
+                            if ((len) == (4))
+                            {
+                                g.eflags = (int) (stbi__get8(s));
+                                g.delay = (int) (stbi__get16le(s));
+                                g.transparent = (int) (stbi__get8(s));
+                            }
+                            else
+                            {
+                                stbi__skip(s, (int) (len));
+                                break;
+                            }
+                        }
+                        while ((len = (int) (stbi__get8(s))) != 0)
+                        {
+                            stbi__skip(s, (int) (len));
+                        }
+                        break;
+                    }
+                    case 0x3B:
+                        return null;
+                    default:
+                        return ((byte*) ((ulong) ((stbi__err("unknown code")) != 0 ? ((byte*) null) : (null))));
+                }
+            }
+        }
+
+        public static void* stbi__gif_load(stbi__context s, int* x, int* y, int* comp, int req_comp,
+            stbi__result_info* ri)
+        {
+            byte* u = null;
+            stbi__gif g = new stbi__gif();
+
+            u = stbi__gif_load_next(s, g, comp, (int) (req_comp));
+            if ((u) != null)
+            {
+                *x = (int) (g.w);
+                *y = (int) (g.h);
+                if (((req_comp) != 0) && (req_comp != 4))
+                    u = stbi__convert_format(u, (int) (4), (int) (req_comp), (uint) (g.w), (uint) (g.h));
+            }
+            else if ((g._out_) != null) free(g._out_);
+
+            return u;
+        }
+
+        public static int stbi__gif_info(stbi__context s, int* x, int* y, int* comp)
+        {
+            return (int) (stbi__gif_info_raw(s, x, y, comp));
+        }
+
+        public static int stbi__bmp_info(stbi__context s, int* x, int* y, int* comp)
+        {
+            void* p;
+            stbi__bmp_data info = new stbi__bmp_data();
+            info.all_a = (uint) (255);
+            p = stbi__bmp_parse_header(s, &info);
+            stbi__rewind(s);
+            if ((p) == (null)) return (int) (0);
+            if ((x) != null) *x = (int) (s.img_x);
+            if ((y) != null) *y = (int) (s.img_y);
+            if ((comp) != null) *comp = (int) ((info.ma) != 0 ? 4 : 3);
+            return (int) (1);
+        }
+
+        public static int stbi__info_main(stbi__context s, int* x, int* y, int* comp)
+        {
+            if ((stbi__jpeg_info(s, x, y, comp)) != 0) return (int) (1);
+            if ((stbi__png_info(s, x, y, comp)) != 0) return (int) (1);
+            if ((stbi__gif_info(s, x, y, comp)) != 0) return (int) (1);
+            if ((stbi__bmp_info(s, x, y, comp)) != 0) return (int) (1);
+            if ((stbi__tga_info(s, x, y, comp)) != 0) return (int) (1);
+            return (int) (stbi__err("unknown image type"));
+        }
+
+        public static int stbi_info_from_memory(byte* buffer, int len, int* x, int* y, int* comp)
+        {
+            stbi__context s = new stbi__context();
+            stbi__start_mem(s, buffer, (int) (len));
+            return (int) (stbi__info_main(s, x, y, comp));
+        }
+
+        public static int stbi_info_from_callbacks(stbi_io_callbacks c, void* user, int* x, int* y, int* comp)
+        {
+            stbi__context s = new stbi__context();
+            stbi__start_callbacks(s, c, user);
+            return (int) (stbi__info_main(s, x, y, comp));
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Imaging/Stb.Image.cs b/MonoGame.Framework/Utilities/Imaging/Stb.Image.cs
new file mode 100644
index 00000000000..d2df16567b6
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Imaging/Stb.Image.cs
@@ -0,0 +1,318 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace MonoGame.Utilities
+{
+    internal unsafe partial class Imaging
+    {
+        public static string LastError;
+
+        public const int STBI__ZFAST_BITS = 9;
+
+        public delegate int ReadCallback(void* user, sbyte* data, int size);
+
+        public delegate int SkipCallback(void* user, int n);
+
+        public delegate int EofCallback(void* user);
+
+        public delegate void idct_block_kernel(byte* output, int out_stride, short* data);
+
+        public delegate void YCbCr_to_RGB_kernel(
+            byte* output, byte* y, byte* pcb, byte* pcr, int count, int step);
+
+        public delegate byte* Resampler(byte* a, byte* b, byte* c, int d, int e);
+
+        public static string stbi__g_failure_reason;
+        public static int stbi__vertically_flip_on_load;
+
+        public class stbi_io_callbacks
+        {
+            public ReadCallback read;
+            public SkipCallback skip;
+            public EofCallback eof;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct img_comp
+        {
+            public int id;
+            public int h, v;
+            public int tq;
+            public int hd, ha;
+            public int dc_pred;
+
+            public int x, y, w2, h2;
+            public byte* data;
+            public void* raw_data;
+            public void* raw_coeff;
+            public byte* linebuf;
+            public short* coeff; // progressive only
+            public int coeff_w, coeff_h; // number of 8x8 coefficient blocks
+        }
+
+        public class stbi__jpeg
+        {
+            public stbi__context s;
+            public readonly PinnedArray<stbi__huffman> huff_dc = new PinnedArray<stbi__huffman>(4);
+            public readonly PinnedArray<stbi__huffman> huff_ac = new PinnedArray<stbi__huffman>(4);
+            public readonly PinnedArray<ushort>[] dequant;
+
+            public readonly PinnedArray<short>[] fast_ac;
+
+// sizes for components, interleaved MCUs
+            public int img_h_max, img_v_max;
+            public int img_mcu_x, img_mcu_y;
+            public int img_mcu_w, img_mcu_h;
+
+// definition of jpeg image component
+            public img_comp[] img_comp = new img_comp[4];
+
+            public uint code_buffer; // jpeg entropy-coded buffer
+            public int code_bits; // number of valid bits
+            public byte marker; // marker seen while filling entropy buffer
+            public int nomore; // flag if we saw a marker so must stop
+
+            public int progressive;
+            public int spec_start;
+            public int spec_end;
+            public int succ_high;
+            public int succ_low;
+            public int eob_run;
+            public int jfif;
+            public int app14_color_transform; // Adobe APP14 tag
+            public int rgb;
+
+            public int scan_n;
+            public PinnedArray<int> order = new PinnedArray<int>(4);
+            public int restart_interval, todo;
+
+// kernels
+            public idct_block_kernel idct_block_kernel;
+            public YCbCr_to_RGB_kernel YCbCr_to_RGB_kernel;
+            public Resampler resample_row_hv_2_kernel;
+
+            public stbi__jpeg()
+            {
+                for (var i = 0; i < 4; ++i)
+                {
+                    huff_ac[i] = new stbi__huffman();
+                    huff_dc[i] = new stbi__huffman();
+                }
+
+                for (var i = 0; i < img_comp.Length; ++i)
+                {
+                    img_comp[i] = new img_comp();
+                }
+
+                fast_ac = new PinnedArray<short>[4];
+                for (var i = 0; i < fast_ac.Length; ++i)
+                {
+                    fast_ac[i] = new PinnedArray<short>(1 << STBI__ZFAST_BITS);
+                }
+
+                dequant = new PinnedArray<ushort>[4];
+                for (var i = 0; i < dequant.Length; ++i)
+                {
+                    dequant[i] = new PinnedArray<ushort>(64);
+                }
+            }
+        };
+
+        public class stbi__resample
+        {
+            public Resampler resample;
+            public byte* line0;
+            public byte* line1;
+            public int hs;
+            public int vs;
+            public int w_lores;
+            public int ystep;
+            public int ypos;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct stbi__gif_lzw
+        {
+            public short prefix;
+            public byte first;
+            public byte suffix;
+        }
+
+        public class stbi__gif
+        {
+            public int w;
+            public int h;
+            public byte* _out_;
+            public byte* old_out;
+            public int flags;
+            public int bgindex;
+            public int ratio;
+            public int transparent;
+            public int eflags;
+            public int delay;
+            public PinnedArray<byte> pal;
+            public PinnedArray<byte> lpal;
+            public PinnedArray<stbi__gif_lzw> codes;
+            public byte* color_table;
+            public int parse;
+            public int step;
+            public int lflags;
+            public int start_x;
+            public int start_y;
+            public int max_x;
+            public int max_y;
+            public int cur_x;
+            public int cur_y;
+            public int line_size;
+
+            public stbi__gif()
+            {
+                codes = new PinnedArray<stbi__gif_lzw>(4096);
+                pal = new PinnedArray<byte>(256*4);
+                lpal = new PinnedArray<byte>(256*4);
+            }
+        }
+
+        private static void* stbi__malloc(int size)
+        {
+            return Operations.Malloc(size);
+        }
+
+        private static void* stbi__malloc(ulong size)
+        {
+            return stbi__malloc((int) size);
+        }
+
+        private static void* malloc(ulong size)
+        {
+            return stbi__malloc(size);
+        }
+
+        private static int stbi__err(string str)
+        {
+            LastError = str;
+            return 0;
+        }
+
+        private static void memcpy(void* a, void* b, long size)
+        {
+            Operations.Memcpy(a, b, size);
+        }
+
+        private static void memcpy(void* a, void* b, ulong size)
+        {
+            memcpy(a, b, (long) size);
+        }
+
+        private static void memmove(void* a, void* b, long size)
+        {
+            Operations.MemMove(a, b, size);
+        }
+
+        private static void memmove(void* a, void* b, ulong size)
+        {
+            memmove(a, b, (long) size);
+        }
+
+        private static int memcmp(void* a, void* b, long size)
+        {
+            return Operations.Memcmp(a, b, size);
+        }
+
+        private static int memcmp(void* a, void* b, ulong size)
+        {
+            return memcmp(a, b, (long) size);
+        }
+
+        private static void free(void* a)
+        {
+            Operations.Free(a);
+        }
+
+        private static void memset(void* ptr, int value, long size)
+        {
+            byte* bptr = (byte*) ptr;
+            var bval = (byte) value;
+            for (long i = 0; i < size; ++i)
+            {
+                *bptr++ = bval;
+            }
+        }
+
+        private static void memset(void* ptr, int value, ulong size)
+        {
+            memset(ptr, value, (long) size);
+        }
+
+        private static uint _lrotl(uint x, int y)
+        {
+            return (x << y) | (x >> (32 - y));
+        }
+
+        private static void* realloc(void* ptr, long newSize)
+        {
+            return Operations.Realloc(ptr, newSize);
+        }
+
+        private static void* realloc(void* ptr, ulong newSize)
+        {
+            return realloc(ptr, (long) newSize);
+        }
+
+        private static int abs(int v)
+        {
+            return Math.Abs(v);
+        }
+
+        public static void stbi__gif_parse_colortable(stbi__context s, byte* pal, int num_entries, int transp)
+        {
+            int i;
+            for (i = 0; (i) < (num_entries); ++i)
+            {
+                pal[i*4 + 2] = stbi__get8(s);
+                pal[i*4 + 1] = stbi__get8(s);
+                pal[i*4] = stbi__get8(s);
+                pal[i*4 + 3] = (byte) (transp == i ? 0 : 255);
+            }
+        }
+
+        public const long DBL_EXP_MASK = 0x7ff0000000000000L;
+        public const int DBL_MANT_BITS = 52;
+        public const long DBL_SGN_MASK = -1 - 0x7fffffffffffffffL;
+        public const long DBL_MANT_MASK = 0x000fffffffffffffL;
+        public const long DBL_EXP_CLR_MASK = DBL_SGN_MASK | DBL_MANT_MASK;
+
+        /// <summary>
+        /// This code had been borrowed from here: https://github.com/MachineCognitis/C.math.NET
+        /// </summary>
+        /// <param name="number"></param>
+        /// <param name="exponent"></param>
+        /// <returns></returns>
+        private static double frexp(double number, int* exponent)
+        {
+            var bits = BitConverter.DoubleToInt64Bits(number);
+            var exp = (int) ((bits & DBL_EXP_MASK) >> DBL_MANT_BITS);
+            *exponent = 0;
+
+            if (exp == 0x7ff || number == 0D)
+                number += number;
+            else
+            {
+                // Not zero and finite.
+                *exponent = exp - 1022;
+                if (exp == 0)
+                {
+                    // Subnormal, scale number so that it is in [1, 2).
+                    number *= BitConverter.Int64BitsToDouble(0x4350000000000000L); // 2^54
+                    bits = BitConverter.DoubleToInt64Bits(number);
+                    exp = (int) ((bits & DBL_EXP_MASK) >> DBL_MANT_BITS);
+                    *exponent = exp - 1022 - 54;
+                }
+                // Set exponent to -1 so that number is in [0.5, 1).
+                number = BitConverter.Int64BitsToDouble((bits & DBL_EXP_CLR_MASK) | 0x3fe0000000000000L);
+            }
+
+            return number;
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Imaging/Stb.ImageWrite.Generated.cs b/MonoGame.Framework/Utilities/Imaging/Stb.ImageWrite.Generated.cs
new file mode 100644
index 00000000000..bd192cdf9ca
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Imaging/Stb.ImageWrite.Generated.cs
@@ -0,0 +1,1398 @@
+// Generated by Sichem at 10/14/2017 7:35:48 AM
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace MonoGame.Utilities
+{
+    unsafe partial class Imaging
+    {
+        public static ushort[] lengthc =
+        {
+            3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99,
+            115, 131, 163, 195, 227, 258, 259
+        };
+
+        public static byte[] lengtheb =
+        {
+            0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
+        };
+
+        public static ushort[] distc =
+        {
+            1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025,
+            1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 32768
+        };
+
+        public static byte[] disteb =
+        {
+            0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12,
+            12, 13, 13
+        };
+
+        public static uint[] crc_table =
+        {
+            0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535,
+            0x9E6495A3, 0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
+            0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856,
+            0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E,
+            0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6,
+            0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
+            0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87,
+            0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
+            0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97,
+            0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
+            0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158,
+            0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC,
+            0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010,
+            0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
+            0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739,
+            0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D,
+            0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671,
+            0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+            0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA,
+            0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A,
+            0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92,
+            0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
+            0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B,
+            0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B,
+            0x6FB077E1, 0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3,
+            0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
+            0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C,
+            0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8,
+            0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+        };
+
+        public static byte[] stbiw__jpg_ZigZag =
+        {
+            0, 1, 5, 6, 14, 15, 27, 28, 2, 4, 7, 13, 16, 26, 29, 42, 3, 8, 12, 17, 25,
+            30, 41, 43, 9, 11, 18, 24, 31, 40, 44, 53, 10, 19, 23, 32, 39, 45, 52, 54, 20, 22, 33, 38, 46, 51, 55, 60,
+            21, 34, 37,
+            47, 50, 56, 59, 61, 35, 36, 48, 49, 57, 58, 62, 63
+        };
+
+        public static byte[] std_dc_luminance_nrcodes = {0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0};
+        public static byte[] std_dc_luminance_values = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+        public static byte[] std_ac_luminance_nrcodes = {0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d};
+
+        public static byte[] std_ac_luminance_values =
+        {
+            0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
+            0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52,
+            0xd1,
+            0xf0, 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 0x29,
+            0x2a,
+            0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55,
+            0x56,
+            0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+            0x79,
+            0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a,
+            0xa2,
+            0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2,
+            0xc3,
+            0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+            0xe3,
+            0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa
+        };
+
+        public static byte[] std_dc_chrominance_nrcodes = {0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0};
+        public static byte[] std_dc_chrominance_values = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+        public static byte[] std_ac_chrominance_nrcodes = {0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77};
+
+        public static byte[] std_ac_chrominance_values =
+        {
+            0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12,
+            0x41, 0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23,
+            0x33,
+            0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+            0x27,
+            0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53,
+            0x54,
+            0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76,
+            0x77,
+            0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+            0x98,
+            0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8,
+            0xb9,
+            0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
+            0xda,
+            0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa
+        };
+
+        public static ushort[,] YDC_HT =
+        {
+            {0, 2}, {2, 3}, {3, 3}, {4, 3}, {5, 3}, {6, 3}, {14, 4}, {30, 5}, {62, 6}, {126, 7},
+            {254, 8}, {510, 9}
+        };
+
+        public static ushort[,] UVDC_HT =
+        {
+            {0, 2}, {1, 2}, {2, 2}, {6, 3}, {14, 4}, {30, 5}, {62, 6}, {126, 7}, {254, 8},
+            {510, 9}, {1022, 10}, {2046, 11}
+        };
+
+        public static ushort[,] YAC_HT =
+        {
+            {10, 4}, {0, 2}, {1, 2}, {4, 3}, {11, 4}, {26, 5}, {120, 7}, {248, 8}, {1014, 10},
+            {65410, 16}, {65411, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {12, 4}, {27, 5}, {121, 7},
+            {502, 9},
+            {2038, 11}, {65412, 16}, {65413, 16}, {65414, 16}, {65415, 16}, {65416, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0},
+            {0, 0},
+            {0, 0}, {28, 5}, {249, 8}, {1015, 10}, {4084, 12}, {65417, 16}, {65418, 16}, {65419, 16}, {65420, 16},
+            {65421, 16},
+            {65422, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {58, 6}, {503, 9}, {4085, 12}, {65423, 16},
+            {65424, 16},
+            {65425, 16}, {65426, 16}, {65427, 16}, {65428, 16}, {65429, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0},
+            {0, 0},
+            {59, 6}, {1016, 10}, {65430, 16}, {65431, 16}, {65432, 16}, {65433, 16}, {65434, 16}, {65435, 16},
+            {65436, 16},
+            {65437, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {122, 7}, {2039, 11}, {65438, 16}, {65439, 16},
+            {65440, 16}, {65441, 16}, {65442, 16}, {65443, 16}, {65444, 16}, {65445, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0},
+            {0, 0},
+            {0, 0}, {123, 7}, {4086, 12}, {65446, 16}, {65447, 16}, {65448, 16}, {65449, 16}, {65450, 16}, {65451, 16},
+            {65452, 16}, {65453, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {250, 8}, {4087, 12}, {65454, 16},
+            {65455, 16}, {65456, 16}, {65457, 16}, {65458, 16}, {65459, 16}, {65460, 16}, {65461, 16}, {0, 0}, {0, 0},
+            {0, 0},
+            {0, 0}, {0, 0}, {0, 0}, {504, 9}, {32704, 15}, {65462, 16}, {65463, 16}, {65464, 16}, {65465, 16},
+            {65466, 16},
+            {65467, 16}, {65468, 16}, {65469, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {505, 9}, {65470, 16},
+            {65471, 16}, {65472, 16}, {65473, 16}, {65474, 16}, {65475, 16}, {65476, 16}, {65477, 16}, {65478, 16},
+            {0, 0},
+            {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {506, 9}, {65479, 16}, {65480, 16}, {65481, 16}, {65482, 16},
+            {65483, 16},
+            {65484, 16}, {65485, 16}, {65486, 16}, {65487, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0},
+            {1017, 10},
+            {65488, 16}, {65489, 16}, {65490, 16}, {65491, 16}, {65492, 16}, {65493, 16}, {65494, 16}, {65495, 16},
+            {65496, 16},
+            {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {1018, 10}, {65497, 16}, {65498, 16}, {65499, 16},
+            {65500, 16},
+            {65501, 16}, {65502, 16}, {65503, 16}, {65504, 16}, {65505, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0},
+            {0, 0},
+            {2040, 11}, {65506, 16}, {65507, 16}, {65508, 16}, {65509, 16}, {65510, 16}, {65511, 16}, {65512, 16},
+            {65513, 16},
+            {65514, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {65515, 16}, {65516, 16}, {65517, 16},
+            {65518, 16},
+            {65519, 16}, {65520, 16}, {65521, 16}, {65522, 16}, {65523, 16}, {65524, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0},
+            {0, 0},
+            {2041, 11}, {65525, 16}, {65526, 16}, {65527, 16}, {65528, 16}, {65529, 16}, {65530, 16}, {65531, 16},
+            {65532, 16},
+            {65533, 16}, {65534, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}
+        };
+
+        public static ushort[,] UVAC_HT =
+        {
+            {0, 2}, {1, 2}, {4, 3}, {10, 4}, {24, 5}, {25, 5}, {56, 6}, {120, 7}, {500, 9},
+            {1014, 10}, {4084, 12}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {11, 4}, {57, 6}, {246, 8}, {501, 9},
+            {2038, 11}, {4085, 12}, {65416, 16}, {65417, 16}, {65418, 16}, {65419, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0},
+            {0, 0},
+            {0, 0}, {26, 5}, {247, 8}, {1015, 10}, {4086, 12}, {32706, 15}, {65420, 16}, {65421, 16}, {65422, 16},
+            {65423, 16},
+            {65424, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {27, 5}, {248, 8}, {1016, 10}, {4087, 12},
+            {65425, 16},
+            {65426, 16}, {65427, 16}, {65428, 16}, {65429, 16}, {65430, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0},
+            {0, 0},
+            {58, 6}, {502, 9}, {65431, 16}, {65432, 16}, {65433, 16}, {65434, 16}, {65435, 16}, {65436, 16}, {65437, 16},
+            {65438, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {59, 6}, {1017, 10}, {65439, 16}, {65440, 16},
+            {65441, 16}, {65442, 16}, {65443, 16}, {65444, 16}, {65445, 16}, {65446, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0},
+            {0, 0},
+            {0, 0}, {121, 7}, {2039, 11}, {65447, 16}, {65448, 16}, {65449, 16}, {65450, 16}, {65451, 16}, {65452, 16},
+            {65453, 16}, {65454, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {122, 7}, {2040, 11}, {65455, 16},
+            {65456, 16}, {65457, 16}, {65458, 16}, {65459, 16}, {65460, 16}, {65461, 16}, {65462, 16}, {0, 0}, {0, 0},
+            {0, 0},
+            {0, 0}, {0, 0}, {0, 0}, {249, 8}, {65463, 16}, {65464, 16}, {65465, 16}, {65466, 16}, {65467, 16},
+            {65468, 16},
+            {65469, 16}, {65470, 16}, {65471, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {503, 9}, {65472, 16},
+            {65473, 16}, {65474, 16}, {65475, 16}, {65476, 16}, {65477, 16}, {65478, 16}, {65479, 16}, {65480, 16},
+            {0, 0},
+            {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {504, 9}, {65481, 16}, {65482, 16}, {65483, 16}, {65484, 16},
+            {65485, 16},
+            {65486, 16}, {65487, 16}, {65488, 16}, {65489, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {505, 9},
+            {65490, 16}, {65491, 16}, {65492, 16}, {65493, 16}, {65494, 16}, {65495, 16}, {65496, 16}, {65497, 16},
+            {65498, 16},
+            {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {506, 9}, {65499, 16}, {65500, 16}, {65501, 16}, {65502, 16},
+            {65503, 16}, {65504, 16}, {65505, 16}, {65506, 16}, {65507, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0},
+            {0, 0},
+            {2041, 11}, {65508, 16}, {65509, 16}, {65510, 16}, {65511, 16}, {65512, 16}, {65513, 16}, {65514, 16},
+            {65515, 16},
+            {65516, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {16352, 14}, {65517, 16}, {65518, 16},
+            {65519, 16},
+            {65520, 16}, {65521, 16}, {65522, 16}, {65523, 16}, {65524, 16}, {65525, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0},
+            {0, 0},
+            {1018, 10}, {32707, 15}, {65526, 16}, {65527, 16}, {65528, 16}, {65529, 16}, {65530, 16}, {65531, 16},
+            {65532, 16},
+            {65533, 16}, {65534, 16}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}
+        };
+
+        public static int[] YQT =
+        {
+            16, 11, 10, 16, 24, 40, 51, 61, 12, 12, 14, 19, 26, 58, 60, 55, 14, 13, 16, 24, 40, 57, 69,
+            56, 14, 17, 22, 29, 51, 87, 80, 62, 18, 22, 37, 56, 68, 109, 103, 77, 24, 35, 55, 64, 81, 104, 113, 92, 49,
+            64, 78,
+            87, 103, 121, 120, 101, 72, 92, 95, 98, 112, 100, 103, 99
+        };
+
+        public static int[] UVQT =
+        {
+            17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66, 99, 99, 99, 99, 24, 26, 56, 99, 99, 99, 99,
+            99, 47, 66, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+            99, 99,
+            99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99
+        };
+
+        public static float[] aasf =
+        {
+            1.0f*2.828427125f, 1.387039845f*2.828427125f, 1.306562965f*2.828427125f,
+            1.175875602f*2.828427125f, 1.0f*2.828427125f, 0.785694958f*2.828427125f, 0.541196100f*2.828427125f,
+            0.275899379f*2.828427125f
+        };
+
+        public static byte[] head0 =
+        {
+            0xFF, 0xD8, 0xFF, 0xE0, 0, 0x10, (byte) ('J'), (byte) ('F'), (byte) ('I'), (byte) ('F'),
+            0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0xFF, 0xDB, 0, 0x84, 0
+        };
+
+        public static byte[] head2 = {0xFF, 0xDA, 0, 0xC, 3, 1, 0, 2, 0x11, 3, 0x11, 0, 0x3F, 0};
+
+        public static void stbiw__putc(stbi__write_context s, byte c)
+        {
+            s.func(s.context, &c, (int) (1));
+        }
+
+        public static void stbiw__write3(stbi__write_context s, byte a, byte b, byte c)
+        {
+            byte* arr = stackalloc byte[3];
+            arr[0] = (byte) (a);
+            arr[1] = (byte) (b);
+            arr[2] = (byte) (c);
+            s.func(s.context, arr, (int) (3));
+        }
+
+        public static void stbiw__write_pixel(stbi__write_context s, int rgb_dir, int comp, int write_alpha,
+            int expand_mono,
+            byte* d)
+        {
+            byte* bg = stackalloc byte[3];
+            bg[0] = (byte) (255);
+            bg[1] = (byte) (0);
+            bg[2] = (byte) (255);
+            byte* px = stackalloc byte[3];
+            int k;
+            if ((write_alpha) < (0)) s.func(s.context, &d[comp - 1], (int) (1));
+            switch (comp)
+            {
+                case 1:
+                case 2:
+                    if ((expand_mono) != 0) stbiw__write3(s, (byte) (d[0]), (byte) (d[0]), (byte) (d[0]));
+                    else s.func(s.context, d, (int) (1));
+                    break;
+                case 3:
+                case 4:
+                    if (((comp) == (4)) && (write_alpha == 0))
+                    {
+                        for (k = (int) (0); (k) < (3); ++k)
+                        {
+                            px[k] = (byte) (bg[k] + ((d[k] - bg[k])*d[3])/255);
+                        }
+                        stbiw__write3(s, (byte) (px[1 - rgb_dir]), (byte) (px[1]), (byte) (px[1 + rgb_dir]));
+                        break;
+                    }
+                    stbiw__write3(s, (byte) (d[1 - rgb_dir]), (byte) (d[1]), (byte) (d[1 + rgb_dir]));
+                    break;
+            }
+
+            if ((write_alpha) > (0)) s.func(s.context, &d[comp - 1], (int) (1));
+        }
+
+        public static void stbiw__write_pixels(stbi__write_context s, int rgb_dir, int vdir, int x, int y, int comp,
+            void* data, int write_alpha, int scanline_pad, int expand_mono)
+        {
+            uint zero = (uint) (0);
+            int i;
+            int j;
+            int j_end;
+            if (y <= 0) return;
+            if ((vdir) < (0))
+            {
+                j_end = (int) (-1);
+                j = (int) (y - 1);
+            }
+            else
+            {
+                j_end = (int) (y);
+                j = (int) (0);
+            }
+
+            for (; j != j_end; j += (int) (vdir))
+            {
+                for (i = (int) (0); (i) < (x); ++i)
+                {
+                    byte* d = (byte*) (data) + (j*x + i)*comp;
+                    stbiw__write_pixel(s, (int) (rgb_dir), (int) (comp), (int) (write_alpha), (int) (expand_mono), d);
+                }
+                s.func(s.context, &zero, (int) (scanline_pad));
+            }
+        }
+
+        public static int stbi_write_bmp_core(stbi__write_context s, int x, int y, int comp, void* data)
+        {
+            int pad = (int) ((-x*3) & 3);
+            return
+                (int)
+                    (stbiw__outfile(s, (int) (-1), (int) (-1), (int) (x), (int) (y), (int) (comp), (int) (1), data,
+                        (int) (0),
+                        (int) (pad), "11 4 22 44 44 22 444444", (int) ('B'), (int) ('M'),
+                        (int) (14 + 40 + (x*3 + pad)*y), (int) (0),
+                        (int) (0), (int) (14 + 40), (int) (40), (int) (x), (int) (y), (int) (1), (int) (24), (int) (0),
+                        (int) (0),
+                        (int) (0), (int) (0), (int) (0), (int) (0)));
+        }
+
+        public static int stbi_write_tga_core(stbi__write_context s, int x, int y, int comp, void* data)
+        {
+            int has_alpha = (((comp) == (2)) || ((comp) == (4))) ? 1 : 0;
+            int colorbytes = (int) ((has_alpha) != 0 ? comp - 1 : comp);
+            int format = (int) ((colorbytes) < (2) ? 3 : 2);
+            if (((y) < (0)) || ((x) < (0))) return (int) (0);
+            if (stbi_write_tga_with_rle == 0)
+            {
+                return
+                    (int)
+                        (stbiw__outfile(s, (int) (-1), (int) (-1), (int) (x), (int) (y), (int) (comp), (int) (0), data,
+                            (int) (has_alpha),
+                            (int) (0), "111 221 2222 11", (int) (0), (int) (0), (int) (format), (int) (0), (int) (0),
+                            (int) (0), (int) (0),
+                            (int) (0), (int) (x), (int) (y), (int) ((colorbytes + has_alpha)*8), (int) (has_alpha*8)));
+            }
+            else
+            {
+                int i;
+                int j;
+                int k;
+                stbiw__writef(s, "111 221 2222 11", (int) (0), (int) (0), (int) (format + 8), (int) (0), (int) (0),
+                    (int) (0),
+                    (int) (0), (int) (0), (int) (x), (int) (y), (int) ((colorbytes + has_alpha)*8), (int) (has_alpha*8));
+                for (j = (int) (y - 1); (j) >= (0); --j)
+                {
+                    byte* row = (byte*) (data) + j*x*comp;
+                    int len;
+                    for (i = (int) (0); (i) < (x); i += (int) (len))
+                    {
+                        byte* begin = row + i*comp;
+                        int diff = (int) (1);
+                        len = (int) (1);
+                        if ((i) < (x - 1))
+                        {
+                            ++len;
+                            diff = (int) (memcmp(begin, row + (i + 1)*comp, (ulong) (comp)));
+                            if ((diff) != 0)
+                            {
+                                byte* prev = begin;
+                                for (k = (int) (i + 2); ((k) < (x)) && ((len) < (128)); ++k)
+                                {
+                                    if ((memcmp(prev, row + k*comp, (ulong) (comp))) != 0)
+                                    {
+                                        prev += comp;
+                                        ++len;
+                                    }
+                                    else
+                                    {
+                                        --len;
+                                        break;
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                for (k = (int) (i + 2); ((k) < (x)) && ((len) < (128)); ++k)
+                                {
+                                    if (memcmp(begin, row + k*comp, (ulong) (comp)) == 0)
+                                    {
+                                        ++len;
+                                    }
+                                    else
+                                    {
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        if ((diff) != 0)
+                        {
+                            byte header = (byte) ((len - 1) & 0xff);
+                            s.func(s.context, &header, (int) (1));
+                            for (k = (int) (0); (k) < (len); ++k)
+                            {
+                                stbiw__write_pixel(s, (int) (-1), (int) (comp), (int) (has_alpha), (int) (0),
+                                    begin + k*comp);
+                            }
+                        }
+                        else
+                        {
+                            byte header = (byte) ((len - 129) & 0xff);
+                            s.func(s.context, &header, (int) (1));
+                            stbiw__write_pixel(s, (int) (-1), (int) (comp), (int) (has_alpha), (int) (0), begin);
+                        }
+                    }
+                }
+            }
+
+            return (int) (1);
+        }
+
+        public static void stbiw__linear_to_rgbe(byte* rgbe, float* linear)
+        {
+            int exponent;
+            float maxcomp =
+                (float)
+                    ((linear[0]) > ((linear[1]) > (linear[2]) ? (linear[1]) : (linear[2]))
+                        ? (linear[0])
+                        : ((linear[1]) > (linear[2]) ? (linear[1]) : (linear[2])));
+            if ((maxcomp) < (1e-32f))
+            {
+                rgbe[0] = (byte) (rgbe[1] = (byte) (rgbe[2] = (byte) (rgbe[3] = (byte) (0))));
+            }
+            else
+            {
+                float normalize = (float) ((float) (frexp((double) (maxcomp), &exponent))*256.0f/maxcomp);
+                rgbe[0] = ((byte) (linear[0]*normalize));
+                rgbe[1] = ((byte) (linear[1]*normalize));
+                rgbe[2] = ((byte) (linear[2]*normalize));
+                rgbe[3] = ((byte) (exponent + 128));
+            }
+
+        }
+
+        public static void stbiw__write_run_data(stbi__write_context s, int length, byte databyte)
+        {
+            byte lengthbyte = (byte) ((length + 128) & 0xff);
+            s.func(s.context, &lengthbyte, (int) (1));
+            s.func(s.context, &databyte, (int) (1));
+        }
+
+        public static void stbiw__write_dump_data(stbi__write_context s, int length, byte* data)
+        {
+            byte lengthbyte = (byte) ((length) & 0xff);
+            s.func(s.context, &lengthbyte, (int) (1));
+            s.func(s.context, data, (int) (length));
+        }
+
+        public static void* stbiw__sbgrowf(void** arr, int increment, int itemsize)
+        {
+            int m = (int) (*arr != null ? 2*((int*) (*arr) - 2)[0] + increment : increment + 1);
+            void* p = realloc(*arr != null ? ((int*) (*arr) - 2) : ((int*) (0)), (ulong) (itemsize*m + sizeof (int)*2));
+            if ((p) != null)
+            {
+                if (*arr == null) ((int*) (p))[1] = (int) (0);
+                *arr = (void*) ((int*) (p) + 2);
+                ((int*) (*arr) - 2)[0] = (int) (m);
+            }
+
+            return *arr;
+        }
+
+        public static byte* stbiw__zlib_flushf(byte* data, uint* bitbuffer, int* bitcount)
+        {
+            while ((*bitcount) >= (8))
+            {
+                if ((((data) == null) || ((((int*) (data) - 2)[1] + (1)) >= (((int*) (data) - 2)[0]))))
+                {
+                    stbiw__sbgrowf((void**) (&(data)), (int) (1), sizeof (byte));
+                }
+                (data)[((int*) (data) - 2)[1]++] = ((byte) ((*bitbuffer) & 0xff));
+                *bitbuffer >>= 8;
+                *bitcount -= (int) (8);
+            }
+            return data;
+        }
+
+        public static int stbiw__zlib_bitrev(int code, int codebits)
+        {
+            int res = (int) (0);
+            while ((codebits--) != 0)
+            {
+                res = (int) ((res << 1) | (code & 1));
+                code >>= 1;
+            }
+            return (int) (res);
+        }
+
+        public static uint stbiw__zlib_countm(byte* a, byte* b, int limit)
+        {
+            int i;
+            for (i = (int) (0); ((i) < (limit)) && ((i) < (258)); ++i)
+            {
+                if (a[i] != b[i]) break;
+            }
+            return (uint) (i);
+        }
+
+        public static uint stbiw__zhash(byte* data)
+        {
+            uint hash = (uint) (data[0] + (data[1] << 8) + (data[2] << 16));
+            hash ^= (uint) (hash << 3);
+            hash += (uint) (hash >> 5);
+            hash ^= (uint) (hash << 4);
+            hash += (uint) (hash >> 17);
+            hash ^= (uint) (hash << 25);
+            hash += (uint) (hash >> 6);
+            return (uint) (hash);
+        }
+
+        public static byte* stbi_zlib_compress(byte* data, int data_len, int* out_len, int quality)
+        {
+            uint bitbuf = (uint) (0);
+            int i;
+            int j;
+            int bitcount = (int) (0);
+            byte* _out_ = null;
+            byte*** hash_table = (byte***) (malloc((ulong) (16384*sizeof (byte**))));
+            if ((quality) < (5)) quality = (int) (5);
+            if ((((_out_) == null) || ((((int*) (_out_) - 2)[1] + (1)) >= (((int*) (_out_) - 2)[0]))))
+            {
+                stbiw__sbgrowf((void**) (&(_out_)), (int) (1), sizeof (byte));
+            }
+
+            (_out_)[((int*) (_out_) - 2)[1]++] = (byte) (0x78);
+            if ((((_out_) == null) || ((((int*) (_out_) - 2)[1] + (1)) >= (((int*) (_out_) - 2)[0]))))
+            {
+                stbiw__sbgrowf((void**) (&(_out_)), (int) (1), sizeof (byte));
+            }
+
+            (_out_)[((int*) (_out_) - 2)[1]++] = (byte) (0x5e);
+            {
+                bitbuf |= (uint) ((1) << bitcount);
+                bitcount += (int) (1);
+                _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+            }
+
+            {
+                bitbuf |= (uint) ((1) << bitcount);
+                bitcount += (int) (2);
+                _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+            }
+
+            for (i = (int) (0); (i) < (16384); ++i)
+            {
+                hash_table[i] = null;
+            }
+            i = (int) (0);
+            while ((i) < (data_len - 3))
+            {
+                int h = (int) (stbiw__zhash(data + i) & (16384 - 1));
+                int best = (int) (3);
+                byte* bestloc = null;
+                byte** hlist = hash_table[h];
+                int n = (int) (hlist != null ? ((int*) (hlist) - 2)[1] : 0);
+                for (j = (int) (0); (j) < (n); ++j)
+                {
+                    if ((hlist[j] - data) > (i - 32768))
+                    {
+                        int d = (int) (stbiw__zlib_countm(hlist[j], data + i, (int) (data_len - i)));
+                        if ((d) >= (best))
+                        {
+                            best = (int) (d);
+                            bestloc = hlist[j];
+                        }
+                    }
+                }
+                if (((hash_table[h]) != null) && ((((int*) (hash_table[h]) - 2)[1]) == (2*quality)))
+                {
+                    memmove(hash_table[h], hash_table[h] + quality, (ulong) (sizeof (byte*)*quality));
+                    ((int*) (hash_table[h]) - 2)[1] = (int) (quality);
+                }
+                if ((((hash_table[h]) == null) ||
+                     ((((int*) (hash_table[h]) - 2)[1] + (1)) >= (((int*) (hash_table[h]) - 2)[0]))))
+                {
+                    stbiw__sbgrowf((void**) (&(hash_table[h])), (int) (1), sizeof (byte*));
+                }
+                (hash_table[h])[((int*) (hash_table[h]) - 2)[1]++] = (data + i);
+                if ((bestloc) != null)
+                {
+                    h = (int) (stbiw__zhash(data + i + 1) & (16384 - 1));
+                    hlist = hash_table[h];
+                    n = (int) (hlist != null ? ((int*) (hlist) - 2)[1] : 0);
+                    for (j = (int) (0); (j) < (n); ++j)
+                    {
+                        if ((hlist[j] - data) > (i - 32767))
+                        {
+                            int e = (int) (stbiw__zlib_countm(hlist[j], data + i + 1, (int) (data_len - i - 1)));
+                            if ((e) > (best))
+                            {
+                                bestloc = null;
+                                break;
+                            }
+                        }
+                    }
+                }
+                if ((bestloc) != null)
+                {
+                    int d = (int) (data + i - bestloc);
+                    for (j = (int) (0); (best) > (lengthc[j + 1] - 1); ++j)
+                    {
+                    }
+                    if (j + 257 <= 143)
+                    {
+                        bitbuf |= (uint) ((stbiw__zlib_bitrev((int) (0x30 + (j + 257)), (int) (8))) << bitcount);
+                        bitcount += (int) (8);
+                        _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+                    }
+                    else if (j + 257 <= 255)
+                    {
+                        bitbuf |= (uint) ((stbiw__zlib_bitrev((int) (0x190 + (j + 257) - 144), (int) (9))) << bitcount);
+                        bitcount += (int) (9);
+                        _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+                    }
+                    else if (j + 257 <= 279)
+                    {
+                        bitbuf |= (uint) ((stbiw__zlib_bitrev((int) (0 + (j + 257) - 256), (int) (7))) << bitcount);
+                        bitcount += (int) (7);
+                        _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+                    }
+                    else
+                    {
+                        bitbuf |= (uint) ((stbiw__zlib_bitrev((int) (0xc0 + (j + 257) - 280), (int) (8))) << bitcount);
+                        bitcount += (int) (8);
+                        _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+                    }
+                    if ((lengtheb[j]) != 0)
+                    {
+                        bitbuf |= (uint) ((best - lengthc[j]) << bitcount);
+                        bitcount += (int) (lengtheb[j]);
+                        _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+                    }
+                    for (j = (int) (0); (d) > (distc[j + 1] - 1); ++j)
+                    {
+                    }
+                    {
+                        bitbuf |= (uint) ((stbiw__zlib_bitrev((int) (j), (int) (5))) << bitcount);
+                        bitcount += (int) (5);
+                        _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+                    }
+                    if ((disteb[j]) != 0)
+                    {
+                        bitbuf |= (uint) ((d - distc[j]) << bitcount);
+                        bitcount += (int) (disteb[j]);
+                        _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+                    }
+                    i += (int) (best);
+                }
+                else
+                {
+                    if (data[i] <= 143)
+                    {
+                        bitbuf |= (uint) ((stbiw__zlib_bitrev((int) (0x30 + (data[i])), (int) (8))) << bitcount);
+                        bitcount += (int) (8);
+                        _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+                    }
+                    else
+                    {
+                        bitbuf |= (uint) ((stbiw__zlib_bitrev((int) (0x190 + (data[i]) - 144), (int) (9))) << bitcount);
+                        bitcount += (int) (9);
+                        _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+                    }
+                    ++i;
+                }
+            }
+            for (; (i) < (data_len); ++i)
+            {
+                if (data[i] <= 143)
+                {
+                    bitbuf |= (uint) ((stbiw__zlib_bitrev((int) (0x30 + (data[i])), (int) (8))) << bitcount);
+                    bitcount += (int) (8);
+                    _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+                }
+                else
+                {
+                    bitbuf |= (uint) ((stbiw__zlib_bitrev((int) (0x190 + (data[i]) - 144), (int) (9))) << bitcount);
+                    bitcount += (int) (9);
+                    _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+                }
+            }
+            if (256 <= 143)
+            {
+                bitbuf |= (uint) ((stbiw__zlib_bitrev((int) (0x30 + (256)), (int) (8))) << bitcount);
+                bitcount += (int) (8);
+                _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+            }
+            else if (256 <= 255)
+            {
+                bitbuf |= (uint) ((stbiw__zlib_bitrev((int) (0x190 + (256) - 144), (int) (9))) << bitcount);
+                bitcount += (int) (9);
+                _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+            }
+            else if (256 <= 279)
+            {
+                bitbuf |= (uint) ((stbiw__zlib_bitrev((int) (0 + (256) - 256), (int) (7))) << bitcount);
+                bitcount += (int) (7);
+                _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+            }
+            else
+            {
+                bitbuf |= (uint) ((stbiw__zlib_bitrev((int) (0xc0 + (256) - 280), (int) (8))) << bitcount);
+                bitcount += (int) (8);
+                _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+            }
+
+            while ((bitcount) != 0)
+            {
+                bitbuf |= (uint) ((0) << bitcount);
+                bitcount += (int) (1);
+                _out_ = stbiw__zlib_flushf(_out_, &bitbuf, &bitcount);
+            }
+            for (i = (int) (0); (i) < (16384); ++i)
+            {
+                if ((hash_table[i]) != null)
+                {
+                    free(((int*) (hash_table[i]) - 2));
+                }
+            }
+            free(hash_table);
+            {
+                uint s1 = (uint) (1);
+                uint s2 = (uint) (0);
+                int blocklen = (int) (data_len%5552);
+                j = (int) (0);
+                while ((j) < (data_len))
+                {
+                    for (i = (int) (0); (i) < (blocklen); ++i)
+                    {
+                        s1 += (uint) (data[j + i]);
+                        s2 += (uint) (s1);
+                    }
+                    s1 %= (uint) (65521);
+                    s2 %= (uint) (65521);
+                    j += (int) (blocklen);
+                    blocklen = (int) (5552);
+                }
+                if ((((_out_) == null) || ((((int*) (_out_) - 2)[1] + (1)) >= (((int*) (_out_) - 2)[0]))))
+                {
+                    stbiw__sbgrowf((void**) (&(_out_)), (int) (1), sizeof (byte));
+                }
+                (_out_)[((int*) (_out_) - 2)[1]++] = ((byte) ((s2 >> 8) & 0xff));
+                if ((((_out_) == null) || ((((int*) (_out_) - 2)[1] + (1)) >= (((int*) (_out_) - 2)[0]))))
+                {
+                    stbiw__sbgrowf((void**) (&(_out_)), (int) (1), sizeof (byte));
+                }
+                (_out_)[((int*) (_out_) - 2)[1]++] = ((byte) ((s2) & 0xff));
+                if ((((_out_) == null) || ((((int*) (_out_) - 2)[1] + (1)) >= (((int*) (_out_) - 2)[0]))))
+                {
+                    stbiw__sbgrowf((void**) (&(_out_)), (int) (1), sizeof (byte));
+                }
+                (_out_)[((int*) (_out_) - 2)[1]++] = ((byte) ((s1 >> 8) & 0xff));
+                if ((((_out_) == null) || ((((int*) (_out_) - 2)[1] + (1)) >= (((int*) (_out_) - 2)[0]))))
+                {
+                    stbiw__sbgrowf((void**) (&(_out_)), (int) (1), sizeof (byte));
+                }
+                (_out_)[((int*) (_out_) - 2)[1]++] = ((byte) ((s1) & 0xff));
+            }
+
+            *out_len = (int) (((int*) (_out_) - 2)[1]);
+            memmove(((int*) (_out_) - 2), _out_, (ulong) (*out_len));
+            return (byte*) ((int*) (_out_) - 2);
+        }
+
+        public static uint stbiw__crc32(byte* buffer, int len)
+        {
+            uint crc = (uint) (~0u);
+            int i;
+            for (i = (int) (0); (i) < (len); ++i)
+            {
+                crc = (uint) ((crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)]);
+            }
+            return (uint) (~crc);
+        }
+
+        public static void stbiw__wpcrc(byte** data, int len)
+        {
+            uint crc = (uint) (stbiw__crc32(*data - len - 4, (int) (len + 4)));
+            (*data)[0] = ((byte) (((crc) >> 24) & 0xff));
+            (*data)[1] = ((byte) (((crc) >> 16) & 0xff));
+            (*data)[2] = ((byte) (((crc) >> 8) & 0xff));
+            (*data)[3] = ((byte) ((crc) & 0xff));
+            (*data) += 4;
+        }
+
+        public static byte stbiw__paeth(int a, int b, int c)
+        {
+            int p = (int) (a + b - c);
+            int pa = (int) (abs((int) (p - a)));
+            int pb = (int) (abs((int) (p - b)));
+            int pc = (int) (abs((int) (p - c)));
+            if ((pa <= pb) && (pa <= pc)) return (byte) ((a) & 0xff);
+            if (pb <= pc) return (byte) ((b) & 0xff);
+            return (byte) ((c) & 0xff);
+        }
+
+        public static byte* stbi_write_png_to_mem(byte* pixels, int stride_bytes, int x, int y, int n, int* out_len)
+        {
+            int* ctype = stackalloc int[5];
+            ctype[0] = (int) (-1);
+            ctype[1] = (int) (0);
+            ctype[2] = (int) (4);
+            ctype[3] = (int) (2);
+            ctype[4] = (int) (6);
+
+            byte* sig = stackalloc byte[8];
+            sig[0] = (byte) (137);
+            sig[1] = (byte) (80);
+            sig[2] = (byte) (78);
+            sig[3] = (byte) (71);
+            sig[4] = (byte) (13);
+            sig[5] = (byte) (10);
+            sig[6] = (byte) (26);
+            sig[7] = (byte) (10);
+
+            byte* _out_;
+            byte* o;
+            byte* filt;
+            byte* zlib;
+            sbyte* line_buffer;
+            int i;
+            int j;
+            int k;
+            int p;
+            int zlen;
+            if ((stride_bytes) == (0)) stride_bytes = (int) (x*n);
+            filt = (byte*) (malloc((ulong) ((x*n + 1)*y)));
+            if (filt == null) return null;
+            line_buffer = (sbyte*) (malloc((ulong) (x*n)));
+            if (line_buffer == null)
+            {
+                free(filt);
+                return null;
+            }
+
+            for (j = (int) (0); (j) < (y); ++j)
+            {
+                int* mapping = stackalloc int[5];
+                mapping[0] = (int) (0);
+                mapping[1] = (int) (1);
+                mapping[2] = (int) (2);
+                mapping[3] = (int) (3);
+                mapping[4] = (int) (4);
+                int* firstmap = stackalloc int[5];
+                firstmap[0] = (int) (0);
+                firstmap[1] = (int) (1);
+                firstmap[2] = (int) (0);
+                firstmap[3] = (int) (5);
+                firstmap[4] = (int) (6);
+                int* mymap = (j != 0) ? mapping : firstmap;
+                int best = (int) (0);
+                int bestval = (int) (0x7fffffff);
+                for (p = (int) (0); (p) < (2); ++p)
+                {
+                    for (k = (int) ((p) != 0 ? best : 0); (k) < (5); ++k)
+                    {
+                        int type = (int) (mymap[k]);
+                        int est = (int) (0);
+                        byte* z = pixels + stride_bytes*j;
+                        for (i = (int) (0); (i) < (n); ++i)
+                        {
+                            switch (type)
+                            {
+                                case 0:
+                                    line_buffer[i] = (sbyte) (z[i]);
+                                    break;
+                                case 1:
+                                    line_buffer[i] = (sbyte) (z[i]);
+                                    break;
+                                case 2:
+                                    line_buffer[i] = (sbyte) (z[i] - z[i - stride_bytes]);
+                                    break;
+                                case 3:
+                                    line_buffer[i] = (sbyte) (z[i] - (z[i - stride_bytes] >> 1));
+                                    break;
+                                case 4:
+                                    line_buffer[i] =
+                                        ((sbyte)
+                                            (z[i] - stbiw__paeth((int) (0), (int) (z[i - stride_bytes]), (int) (0))));
+                                    break;
+                                case 5:
+                                    line_buffer[i] = (sbyte) (z[i]);
+                                    break;
+                                case 6:
+                                    line_buffer[i] = (sbyte) (z[i]);
+                                    break;
+                            }
+                        }
+                        for (i = (int) (n); (i) < (x*n); ++i)
+                        {
+                            switch (type)
+                            {
+                                case 0:
+                                    line_buffer[i] = (sbyte) (z[i]);
+                                    break;
+                                case 1:
+                                    line_buffer[i] = (sbyte) (z[i] - z[i - n]);
+                                    break;
+                                case 2:
+                                    line_buffer[i] = (sbyte) (z[i] - z[i - stride_bytes]);
+                                    break;
+                                case 3:
+                                    line_buffer[i] = (sbyte) (z[i] - ((z[i - n] + z[i - stride_bytes]) >> 1));
+                                    break;
+                                case 4:
+                                    line_buffer[i] =
+                                        (sbyte)
+                                            (z[i] -
+                                             stbiw__paeth((int) (z[i - n]), (int) (z[i - stride_bytes]),
+                                                 (int) (z[i - stride_bytes - n])));
+                                    break;
+                                case 5:
+                                    line_buffer[i] = (sbyte) (z[i] - (z[i - n] >> 1));
+                                    break;
+                                case 6:
+                                    line_buffer[i] =
+                                        (sbyte) (z[i] - stbiw__paeth((int) (z[i - n]), (int) (0), (int) (0)));
+                                    break;
+                            }
+                        }
+                        if ((p) != 0) break;
+                        for (i = (int) (0); (i) < (x*n); ++i)
+                        {
+                            est += (int) (abs((int) (line_buffer[i])));
+                        }
+                        if ((est) < (bestval))
+                        {
+                            bestval = (int) (est);
+                            best = (int) (k);
+                        }
+                    }
+                }
+                filt[j*(x*n + 1)] = ((byte) (best));
+                memmove(filt + j*(x*n + 1) + 1, line_buffer, (ulong) (x*n));
+            }
+            free(line_buffer);
+            zlib = stbi_zlib_compress(filt, (int) (y*(x*n + 1)), &zlen, (int) (8));
+            free(filt);
+            if (zlib == null) return null;
+            _out_ = (byte*) (malloc((ulong) (8 + 12 + 13 + 12 + zlen + 12)));
+            if (_out_ == null) return null;
+            *out_len = (int) (8 + 12 + 13 + 12 + zlen + 12);
+            o = _out_;
+            memmove(o, sig, (ulong) (8));
+            o += 8;
+            (o)[0] = ((byte) (((13) >> 24) & 0xff));
+            (o)[1] = ((byte) (((13) >> 16) & 0xff));
+            (o)[2] = ((byte) (((13) >> 8) & 0xff));
+            (o)[3] = ((byte) ((13) & 0xff));
+            (o) += 4;
+            (o)[0] = ((byte) (("IHDR"[0]) & 0xff));
+            (o)[1] = ((byte) (("IHDR"[1]) & 0xff));
+            (o)[2] = ((byte) (("IHDR"[2]) & 0xff));
+            (o)[3] = ((byte) (("IHDR"[3]) & 0xff));
+            (o) += 4;
+            (o)[0] = ((byte) (((x) >> 24) & 0xff));
+            (o)[1] = ((byte) (((x) >> 16) & 0xff));
+            (o)[2] = ((byte) (((x) >> 8) & 0xff));
+            (o)[3] = ((byte) ((x) & 0xff));
+            (o) += 4;
+            (o)[0] = ((byte) (((y) >> 24) & 0xff));
+            (o)[1] = ((byte) (((y) >> 16) & 0xff));
+            (o)[2] = ((byte) (((y) >> 8) & 0xff));
+            (o)[3] = ((byte) ((y) & 0xff));
+            (o) += 4;
+            *o++ = (byte) (8);
+            *o++ = ((byte) ((ctype[n]) & 0xff));
+            *o++ = (byte) (0);
+            *o++ = (byte) (0);
+            *o++ = (byte) (0);
+            stbiw__wpcrc(&o, (int) (13));
+            (o)[0] = ((byte) (((zlen) >> 24) & 0xff));
+            (o)[1] = ((byte) (((zlen) >> 16) & 0xff));
+            (o)[2] = ((byte) (((zlen) >> 8) & 0xff));
+            (o)[3] = ((byte) ((zlen) & 0xff));
+            (o) += 4;
+            (o)[0] = ((byte) (("IDAT"[0]) & 0xff));
+            (o)[1] = ((byte) (("IDAT"[1]) & 0xff));
+            (o)[2] = ((byte) (("IDAT"[2]) & 0xff));
+            (o)[3] = ((byte) (("IDAT"[3]) & 0xff));
+            (o) += 4;
+            memmove(o, zlib, (ulong) (zlen));
+            o += zlen;
+            free(zlib);
+            stbiw__wpcrc(&o, (int) (zlen));
+            (o)[0] = ((byte) (((0) >> 24) & 0xff));
+            (o)[1] = ((byte) (((0) >> 16) & 0xff));
+            (o)[2] = ((byte) (((0) >> 8) & 0xff));
+            (o)[3] = ((byte) ((0) & 0xff));
+            (o) += 4;
+            (o)[0] = ((byte) (("IEND"[0]) & 0xff));
+            (o)[1] = ((byte) (("IEND"[1]) & 0xff));
+            (o)[2] = ((byte) (("IEND"[2]) & 0xff));
+            (o)[3] = ((byte) (("IEND"[3]) & 0xff));
+            (o) += 4;
+            stbiw__wpcrc(&o, (int) (0));
+            return _out_;
+        }
+
+        public static void stbiw__jpg_writeBits(stbi__write_context s, int* bitBufP, int* bitCntP, ushort bs0,
+            ushort bs1)
+        {
+            int bitBuf = (int) (*bitBufP);
+            int bitCnt = (int) (*bitCntP);
+            bitCnt += (int) (bs1);
+            bitBuf |= (int) (bs0 << (24 - bitCnt));
+            while ((bitCnt) >= (8))
+            {
+                byte c = (byte) ((bitBuf >> 16) & 255);
+                stbiw__putc(s, (byte) (c));
+                if ((c) == (255))
+                {
+                    stbiw__putc(s, (byte) (0));
+                }
+                bitBuf <<= 8;
+                bitCnt -= (int) (8);
+            }
+            *bitBufP = (int) (bitBuf);
+            *bitCntP = (int) (bitCnt);
+        }
+
+        public static void stbiw__jpg_DCT(float* d0p, float* d1p, float* d2p, float* d3p, float* d4p, float* d5p,
+            float* d6p,
+            float* d7p)
+        {
+            float d0 = (float) (*d0p);
+            float d1 = (float) (*d1p);
+            float d2 = (float) (*d2p);
+            float d3 = (float) (*d3p);
+            float d4 = (float) (*d4p);
+            float d5 = (float) (*d5p);
+            float d6 = (float) (*d6p);
+            float d7 = (float) (*d7p);
+            float z1;
+            float z2;
+            float z3;
+            float z4;
+            float z5;
+            float z11;
+            float z13;
+            float tmp0 = (float) (d0 + d7);
+            float tmp7 = (float) (d0 - d7);
+            float tmp1 = (float) (d1 + d6);
+            float tmp6 = (float) (d1 - d6);
+            float tmp2 = (float) (d2 + d5);
+            float tmp5 = (float) (d2 - d5);
+            float tmp3 = (float) (d3 + d4);
+            float tmp4 = (float) (d3 - d4);
+            float tmp10 = (float) (tmp0 + tmp3);
+            float tmp13 = (float) (tmp0 - tmp3);
+            float tmp11 = (float) (tmp1 + tmp2);
+            float tmp12 = (float) (tmp1 - tmp2);
+            d0 = (float) (tmp10 + tmp11);
+            d4 = (float) (tmp10 - tmp11);
+            z1 = (float) ((tmp12 + tmp13)*0.707106781f);
+            d2 = (float) (tmp13 + z1);
+            d6 = (float) (tmp13 - z1);
+            tmp10 = (float) (tmp4 + tmp5);
+            tmp11 = (float) (tmp5 + tmp6);
+            tmp12 = (float) (tmp6 + tmp7);
+            z5 = (float) ((tmp10 - tmp12)*0.382683433f);
+            z2 = (float) (tmp10*0.541196100f + z5);
+            z4 = (float) (tmp12*1.306562965f + z5);
+            z3 = (float) (tmp11*0.707106781f);
+            z11 = (float) (tmp7 + z3);
+            z13 = (float) (tmp7 - z3);
+            *d5p = (float) (z13 + z2);
+            *d3p = (float) (z13 - z2);
+            *d1p = (float) (z11 + z4);
+            *d7p = (float) (z11 - z4);
+            *d0p = (float) (d0);
+            *d2p = (float) (d2);
+            *d4p = (float) (d4);
+            *d6p = (float) (d6);
+        }
+
+        public static void stbiw__jpg_calcBits(int val, ushort* bits)
+        {
+            int tmp1 = (int) ((val) < (0) ? -val : val);
+            val = (int) ((val) < (0) ? val - 1 : val);
+            bits[1] = (ushort) (1);
+            while ((tmp1 >>= 1) != 0)
+            {
+                ++bits[1];
+            }
+            bits[0] = (ushort) (val & ((1 << bits[1]) - 1));
+        }
+
+        public static int stbiw__jpg_processDU(stbi__write_context s, int* bitBuf, int* bitCnt, float* CDU, float* fdtbl,
+            int DC, ushort[,] HTDC, ushort[,] HTAC)
+        {
+            ushort* EOB = stackalloc ushort[2];
+            EOB[0] = (ushort) (HTAC[0x00, 0]);
+            EOB[1] = (ushort) (HTAC[0x00, 1]);
+
+            ushort* M16zeroes = stackalloc ushort[2];
+            M16zeroes[0] = (ushort) (HTAC[0xF0, 0]);
+            M16zeroes[1] = (ushort) (HTAC[0xF0, 1]);
+
+            int dataOff;
+            int i;
+            int diff;
+            int end0pos;
+            int* DU = stackalloc int[64];
+            for (dataOff = (int) (0); (dataOff) < (64); dataOff += (int) (8))
+            {
+                stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff + 1], &CDU[dataOff + 2], &CDU[dataOff + 3], &CDU[dataOff + 4],
+                    &CDU[dataOff + 5], &CDU[dataOff + 6], &CDU[dataOff + 7]);
+            }
+            for (dataOff = (int) (0); (dataOff) < (8); ++dataOff)
+            {
+                stbiw__jpg_DCT(&CDU[dataOff], &CDU[dataOff + 8], &CDU[dataOff + 16], &CDU[dataOff + 24],
+                    &CDU[dataOff + 32],
+                    &CDU[dataOff + 40], &CDU[dataOff + 48], &CDU[dataOff + 56]);
+            }
+            for (i = (int) (0); (i) < (64); ++i)
+            {
+                float v = (float) (CDU[i]*fdtbl[i]);
+                DU[stbiw__jpg_ZigZag[i]] = ((int) ((v) < (0) ? v - 0.5f : v + 0.5f));
+            }
+            diff = (int) (DU[0] - DC);
+            if ((diff) == (0))
+            {
+                stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[0, 0], HTDC[0, 1]);
+            }
+            else
+            {
+                ushort* bits = stackalloc ushort[2];
+                stbiw__jpg_calcBits((int) (diff), bits);
+                stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTDC[bits[1], 0], HTDC[bits[1], 1]);
+                stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits[0], bits[1]);
+            }
+
+            end0pos = (int) (63);
+            for (; ((end0pos) > (0)) && ((DU[end0pos]) == (0)); --end0pos)
+            {
+            }
+            if ((end0pos) == (0))
+            {
+                stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB[0], EOB[1]);
+                return (int) (DU[0]);
+            }
+
+            for (i = (int) (1); i <= end0pos; ++i)
+            {
+                int startpos = (int) (i);
+                int nrzeroes;
+                ushort* bits = stackalloc ushort[2];
+                for (; ((DU[i]) == (0)) && (i <= end0pos); ++i)
+                {
+                }
+                nrzeroes = (int) (i - startpos);
+                if ((nrzeroes) >= (16))
+                {
+                    int lng = (int) (nrzeroes >> 4);
+                    int nrmarker;
+                    for (nrmarker = (int) (1); nrmarker <= lng; ++nrmarker)
+                    {
+                        stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes[0], M16zeroes[1]);
+                    }
+                    nrzeroes &= (int) (15);
+                }
+                stbiw__jpg_calcBits((int) (DU[i]), bits);
+                stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes << 4) + bits[1], 0],
+                    HTAC[(nrzeroes << 4) + bits[1], 1]);
+                stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits[0], bits[1]);
+            }
+            if (end0pos != 63)
+            {
+                stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB[0], EOB[1]);
+            }
+
+            return (int) (DU[0]);
+        }
+
+        public static int stbi_write_jpg_core(stbi__write_context s, int width, int height, int comp, void* data,
+            int quality)
+        {
+            int row;
+            int col;
+            int i;
+            int k;
+            float* fdtbl_Y = stackalloc float[64];
+            float* fdtbl_UV = stackalloc float[64];
+            byte* YTable = stackalloc byte[64];
+            byte* UVTable = stackalloc byte[64];
+            if (((((data == null) || (width == 0)) || (height == 0)) || ((comp) > (4))) || ((comp) < (1)))
+            {
+                return (int) (0);
+            }
+
+            quality = (int) ((quality) != 0 ? quality : 90);
+            quality = (int) ((quality) < (1) ? 1 : (quality) > (100) ? 100 : quality);
+            quality = (int) ((quality) < (50) ? 5000/quality : 200 - quality*2);
+            for (i = (int) (0); (i) < (64); ++i)
+            {
+                int uvti;
+                int yti = (int) ((YQT[i]*quality + 50)/100);
+                YTable[stbiw__jpg_ZigZag[i]] = ((byte) ((yti) < (1) ? 1 : (yti) > (255) ? 255 : yti));
+                uvti = (int) ((UVQT[i]*quality + 50)/100);
+                UVTable[stbiw__jpg_ZigZag[i]] = ((byte) ((uvti) < (1) ? 1 : (uvti) > (255) ? 255 : uvti));
+            }
+            for (row = (int) (0) , k = (int) (0); (row) < (8); ++row)
+            {
+                for (col = (int) (0); (col) < (8); ++col , ++k)
+                {
+                    fdtbl_Y[k] = (float) (1/(YTable[stbiw__jpg_ZigZag[k]]*aasf[row]*aasf[col]));
+                    fdtbl_UV[k] = (float) (1/(UVTable[stbiw__jpg_ZigZag[k]]*aasf[row]*aasf[col]));
+                }
+            }
+            {
+                byte* head1 = stackalloc byte[24];
+                head1[0] = (byte) (0xFF);
+                head1[1] = (byte) (0xC0);
+                head1[2] = (byte) (0);
+                head1[3] = (byte) (0x11);
+                head1[4] = (byte) (8);
+                head1[5] = (byte) (height >> 8);
+                head1[6] = (byte) ((height) & 0xff);
+                head1[7] = (byte) (width >> 8);
+                head1[8] = (byte) ((width) & 0xff);
+                head1[9] = (byte) (3);
+                head1[10] = (byte) (1);
+                head1[11] = (byte) (0x11);
+                head1[12] = (byte) (0);
+                head1[13] = (byte) (2);
+                head1[14] = (byte) (0x11);
+                head1[15] = (byte) (1);
+                head1[16] = (byte) (3);
+                head1[17] = (byte) (0x11);
+                head1[18] = (byte) (1);
+                head1[19] = (byte) (0xFF);
+                head1[20] = (byte) (0xC4);
+                head1[21] = (byte) (0x01);
+                head1[22] = (byte) (0xA2);
+                head1[23] = (byte) (0);
+
+                fixed (byte* h = head0)
+                {
+                    s.func(s.context, h, head0.Length);
+                }
+
+
+                s.func(s.context, YTable, 64);
+                stbiw__putc(s, (byte) (1));
+                s.func(s.context, UVTable, 64);
+                s.func(s.context, head1, 24);
+
+                fixed (byte* d = &std_dc_luminance_nrcodes[1])
+                {
+                    s.func(s.context, d, std_dc_chrominance_nrcodes.Length - 1);
+                }
+
+                fixed (byte* d = std_dc_luminance_values)
+                {
+                    s.func(s.context, d, std_dc_chrominance_values.Length);
+                }
+
+                stbiw__putc(s, (byte) (0x10));
+
+                fixed (byte* a = &std_ac_luminance_nrcodes[1])
+                {
+                    s.func(s.context, a, std_ac_luminance_nrcodes.Length - 1);
+                }
+
+                fixed (byte* a = std_ac_luminance_values)
+                {
+                    s.func(s.context, a, std_ac_luminance_values.Length);
+                }
+
+                stbiw__putc(s, (byte) (1));
+
+                fixed (byte* c = &std_dc_chrominance_nrcodes[1])
+                {
+                    s.func(s.context, c, std_dc_chrominance_nrcodes.Length - 1);
+                }
+
+                fixed (byte* c = std_dc_chrominance_values)
+                {
+                    s.func(s.context, c, std_dc_chrominance_values.Length);
+                }
+
+                stbiw__putc(s, (byte) (0x11));
+
+
+                fixed (byte* c = &std_ac_chrominance_nrcodes[1])
+                {
+                    s.func(s.context, c, std_ac_chrominance_nrcodes.Length - 1);
+                }
+
+                fixed (byte* c = std_ac_chrominance_values)
+                {
+                    s.func(s.context, c, std_ac_chrominance_values.Length);
+                }
+
+                fixed (byte* c = head2)
+                {
+                    s.func(s.context, c, head2.Length);
+                }
+            }
+
+            {
+                ushort* fillBits = stackalloc ushort[2];
+                fillBits[0] = (ushort) (0x7F);
+                fillBits[1] = (ushort) (7);
+                byte* imageData = (byte*) (data);
+                int DCY = (int) (0);
+                int DCU = (int) (0);
+                int DCV = (int) (0);
+                int bitBuf = (int) (0);
+                int bitCnt = (int) (0);
+                int ofsG = (int) ((comp) > (2) ? 1 : 0);
+                int ofsB = (int) ((comp) > (2) ? 2 : 0);
+                int x;
+                int y;
+                int pos;
+                float* YDU = stackalloc float[64];
+                float* UDU = stackalloc float[64];
+                float* VDU = stackalloc float[64];
+
+                for (y = (int) (0); (y) < (height); y += (int) (8))
+                {
+                    for (x = (int) (0); (x) < (width); x += (int) (8))
+                    {
+                        for (row = (int) (y) , pos = (int) (0); (row) < (y + 8); ++row)
+                        {
+                            for (col = (int) (x); (col) < (x + 8); ++col , ++pos)
+                            {
+                                int p = (int) (row*width*comp + col*comp);
+                                float r;
+                                float g;
+                                float b;
+                                if ((row) >= (height))
+                                {
+                                    p -= (int) (width*comp*(row + 1 - height));
+                                }
+                                if ((col) >= (width))
+                                {
+                                    p -= (int) (comp*(col + 1 - width));
+                                }
+                                r = (float) (imageData[p + 0]);
+                                g = (float) (imageData[p + ofsG]);
+                                b = (float) (imageData[p + ofsB]);
+                                YDU[pos] = (float) (+0.29900f*r + 0.58700f*g + 0.11400f*b - 128);
+                                UDU[pos] = (float) (-0.16874f*r - 0.33126f*g + 0.50000f*b);
+                                VDU[pos] = (float) (+0.50000f*r - 0.41869f*g - 0.08131f*b);
+                            }
+                        }
+
+                        DCY =
+                            (int) (stbiw__jpg_processDU(s, &bitBuf, &bitCnt, YDU, fdtbl_Y, (int) (DCY), YDC_HT, YAC_HT));
+                        DCU =
+                            (int)
+                                (stbiw__jpg_processDU(s, &bitBuf, &bitCnt, UDU, fdtbl_UV, (int) (DCU), UVDC_HT, UVAC_HT));
+                        DCV =
+                            (int)
+                                (stbiw__jpg_processDU(s, &bitBuf, &bitCnt, VDU, fdtbl_UV, (int) (DCV), UVDC_HT, UVAC_HT));
+                    }
+                }
+                stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits[0], fillBits[1]);
+            }
+
+            stbiw__putc(s, (byte) (0xFF));
+            stbiw__putc(s, (byte) (0xD9));
+            return (int) (1);
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Imaging/Stb.ImageWrite.cs b/MonoGame.Framework/Utilities/Imaging/Stb.ImageWrite.cs
new file mode 100644
index 00000000000..2de1e54dcd6
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Imaging/Stb.ImageWrite.cs
@@ -0,0 +1,138 @@
+using System.Text;
+
+namespace MonoGame.Utilities
+{
+    unsafe partial class Imaging
+    {
+        public static int stbi_write_tga_with_rle = 1;
+
+        public delegate int WriteCallback(void* context, void* data, int size);
+
+        public class stbi__write_context
+        {
+            public WriteCallback func;
+            public void* context;
+        }
+
+        public static void stbi__start_write_callbacks(stbi__write_context s, WriteCallback c, void* context)
+        {
+            s.func = c;
+            s.context = context;
+        }
+
+        public static void stbiw__writefv(stbi__write_context s, string fmt, params object[] v)
+        {
+            var vindex = 0;
+            for (var i = 0; i < fmt.Length; ++i)
+            {
+                var c = fmt[i];
+                switch (c)
+                {
+                    case ' ':
+                        break;
+                    case '1':
+                    {
+                        var x = (byte) ((int) v[vindex++] & 0xff);
+                        s.func(s.context, &x, 1);
+                        break;
+                    }
+                    case '2':
+                    {
+                        var x = (int) v[vindex++];
+                        var b = stackalloc byte[2];
+                        b[0] = (byte) (x & 0xff);
+                        b[1] = (byte) ((x >> 8) & 0xff);
+                        s.func(s.context, b, 2);
+                        break;
+                    }
+                    case '4':
+                    {
+                        var x = (int) v[vindex++];
+                        var b = stackalloc byte[4];
+                        b[0] = (byte) (x & 0xff);
+                        b[1] = (byte) ((x >> 8) & 0xff);
+                        b[2] = (byte) ((x >> 16) & 0xff);
+                        b[3] = (byte) ((x >> 24) & 0xff);
+                        s.func(s.context, b, 4);
+                        break;
+                    }
+                }
+            }
+        }
+
+        public static void stbiw__writef(stbi__write_context s, string fmt, params object[] v)
+        {
+            stbiw__writefv(s, fmt, v);
+        }
+
+        public static int stbiw__outfile(stbi__write_context s, int rgb_dir, int vdir, int x, int y, int comp,
+            int expand_mono, void* data, int alpha, int pad, string fmt, params object[] v)
+        {
+            if ((y < 0) || (x < 0))
+            {
+                return 0;
+            }
+
+            stbiw__writefv(s, fmt, v);
+            stbiw__write_pixels(s, rgb_dir, vdir, x, y, comp, data, alpha, pad, expand_mono);
+            return 1;
+        }
+
+        public static int stbi_write_bmp_to_func(WriteCallback func,
+            void* context,
+            int x,
+            int y,
+            int comp,
+            void* data
+            )
+        {
+            var s = new stbi__write_context();
+            stbi__start_write_callbacks(s, func, context);
+            return stbi_write_bmp_core(s, x, y, comp, data);
+        }
+
+        public static int stbi_write_tga_to_func(WriteCallback func,
+            void* context,
+            int x,
+            int y,
+            int comp,
+            void* data
+            )
+        {
+            var s = new stbi__write_context();
+            stbi__start_write_callbacks(s, func, context);
+            return stbi_write_tga_core(s, x, y, comp, data);
+        }
+
+        public static int stbi_write_png_to_func(WriteCallback func,
+            void* context,
+            int x,
+            int y,
+            int comp,
+            void* data,
+            int stride_bytes
+            )
+        {
+            int len;
+            var png = stbi_write_png_to_mem((byte*) (data), stride_bytes, x, y, comp, &len);
+            if (png == null) return 0;
+            func(context, png, len);
+            free(png);
+            return 1;
+        }
+
+        public static int stbi_write_jpg_to_func(WriteCallback func,
+            void* context,
+            int x,
+            int y,
+            int comp,
+            void* data,
+            int quality
+            )
+        {
+            stbi__write_context s = new stbi__write_context();
+            stbi__start_write_callbacks(s, func, context);
+            return stbi_write_jpg_core(s, x, y, comp, data, quality);
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/InteropHelpers.cs b/MonoGame.Framework/Utilities/InteropHelpers.cs
new file mode 100644
index 00000000000..a738ace49e4
--- /dev/null
+++ b/MonoGame.Framework/Utilities/InteropHelpers.cs
@@ -0,0 +1,35 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace MonoGame.Utilities
+{
+    internal static class InteropHelpers
+    {
+        /// <summary>
+        /// Convert a pointer to a Utf8 null-terminated string to a .NET System.String
+        /// </summary>
+        public static unsafe string Utf8ToString(IntPtr handle)
+        {
+            if (handle == IntPtr.Zero)
+                return string.Empty;
+
+            var ptr = (byte*) handle;
+            while (*ptr != 0)
+                ptr++;
+
+            var len = ptr - (byte*) handle;
+            if (len == 0)
+                return string.Empty;
+
+            var bytes = new byte[len];
+            Marshal.Copy(handle, bytes, 0, bytes.Length);
+
+            return Encoding.UTF8.GetString(bytes);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/Lz4Stream/Lz4DecoderStream.cs b/MonoGame.Framework/Utilities/Lz4Stream/Lz4DecoderStream.cs
new file mode 100644
index 00000000000..50ef05ff51e
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Lz4Stream/Lz4DecoderStream.cs
@@ -0,0 +1,549 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+#define CHECK_ARGS
+#define CHECK_EOF
+//#define LOCAL_SHADOW
+
+using System;
+using System.IO;
+
+namespace MonoGame.Utilities
+{
+	internal class Lz4DecoderStream : Stream
+	{
+		public Lz4DecoderStream()
+		{
+		}
+
+		public Lz4DecoderStream( Stream input, long inputLength = long.MaxValue )
+		{
+			Reset( input, inputLength );
+		}
+
+		public void Reset( Stream input, long inputLength = long.MaxValue )
+		{
+			this.inputLength = inputLength;
+			this.input = input;
+
+			phase = DecodePhase.ReadToken;
+			
+			decodeBufferPos = 0;
+			
+			litLen = 0;
+			matLen = 0;
+			matDst = 0;
+
+			inBufPos = DecBufLen;
+			inBufEnd = DecBufLen;
+		}
+
+        protected override void Dispose(bool disposing)
+		{
+            this.input = null;
+            base.Dispose(disposing);
+		}
+
+		private long inputLength;
+		private Stream input;
+
+		//because we might not be able to match back across invocations,
+		//we have to keep the last window's worth of bytes around for reuse
+		//we use a circular buffer for this - every time we write into this
+		//buffer, we also write the same into our output buffer
+
+		private const int DecBufLen = 0x10000;
+		private const int DecBufMask = 0xFFFF;
+
+		private const int InBufLen = 128;
+
+		private byte[] decodeBuffer = new byte[DecBufLen + InBufLen];
+		private int decodeBufferPos, inBufPos, inBufEnd;
+
+		//we keep track of which phase we're in so that we can jump right back
+		//into the correct part of decoding
+
+		private DecodePhase phase;
+
+		private enum DecodePhase
+		{
+			ReadToken,
+			ReadExLiteralLength,
+			CopyLiteral,
+			ReadOffset,
+			ReadExMatchLength,
+			CopyMatch,
+		}
+
+		//state within interruptable phases and across phase boundaries is
+		//kept here - again, so that we can punt out and restart freely
+
+		private int litLen, matLen, matDst;
+
+		public override int Read( byte[] buffer, int offset, int count )
+		{
+#if CHECK_ARGS
+			if( buffer == null )
+				throw new ArgumentNullException( "buffer" );
+			if( offset < 0 || count < 0 || buffer.Length - count < offset )
+				throw new ArgumentOutOfRangeException();
+
+			if( input == null )
+				throw new InvalidOperationException();
+#endif
+			int nRead, nToRead = count;
+
+			var decBuf = decodeBuffer;
+
+			//the stringy gotos are obnoxious, but their purpose is to
+			//make it *blindingly* obvious how the state machine transitions
+			//back and forth as it reads - remember, we can yield out of
+			//this routine in several places, and we must be able to re-enter
+			//and pick up where we left off!
+
+#if LOCAL_SHADOW
+			var phase = this.phase;
+			var inBufPos = this.inBufPos;
+			var inBufEnd = this.inBufEnd;
+#endif
+			switch( phase )
+			{
+			case DecodePhase.ReadToken:
+				goto readToken;
+
+			case DecodePhase.ReadExLiteralLength:
+				goto readExLiteralLength;
+
+			case DecodePhase.CopyLiteral:
+				goto copyLiteral;
+
+			case DecodePhase.ReadOffset:
+				goto readOffset;
+
+			case DecodePhase.ReadExMatchLength:
+				goto readExMatchLength;
+
+			case DecodePhase.CopyMatch:
+				goto copyMatch;
+			}
+
+		readToken:
+			int tok;
+			if( inBufPos < inBufEnd )
+			{
+				tok = decBuf[inBufPos++];
+			}
+			else
+			{
+#if LOCAL_SHADOW
+				this.inBufPos = inBufPos;
+#endif
+
+				tok = ReadByteCore();
+#if LOCAL_SHADOW
+				inBufPos = this.inBufPos;
+				inBufEnd = this.inBufEnd;
+#endif
+#if CHECK_EOF
+				if( tok == -1 )
+					goto finish;
+#endif
+			}
+
+			litLen = tok >> 4;
+			matLen = (tok & 0xF) + 4;
+
+			switch( litLen )
+			{
+			case 0:
+				phase = DecodePhase.ReadOffset;
+				goto readOffset;
+
+			case 0xF:
+				phase = DecodePhase.ReadExLiteralLength;
+				goto readExLiteralLength;
+
+			default:
+				phase = DecodePhase.CopyLiteral;
+				goto copyLiteral;
+			}
+
+		readExLiteralLength:
+			int exLitLen;
+			if( inBufPos < inBufEnd )
+			{
+				exLitLen = decBuf[inBufPos++];
+			}
+			else
+			{
+#if LOCAL_SHADOW
+				this.inBufPos = inBufPos;
+#endif
+				exLitLen = ReadByteCore();
+#if LOCAL_SHADOW				
+				inBufPos = this.inBufPos;
+				inBufEnd = this.inBufEnd;
+#endif
+
+#if CHECK_EOF
+				if( exLitLen == -1 )
+					goto finish;
+#endif
+			}
+
+			litLen += exLitLen;
+			if( exLitLen == 255 )
+				goto readExLiteralLength;
+
+			phase = DecodePhase.CopyLiteral;
+			goto copyLiteral;
+
+		copyLiteral:
+			int nReadLit = litLen < nToRead ? litLen : nToRead;
+			if( nReadLit != 0 )
+			{
+				if( inBufPos + nReadLit <= inBufEnd )
+				{
+					int ofs = offset;
+
+					for( int c = nReadLit; c-- != 0; )
+						buffer[ofs++] = decBuf[inBufPos++];
+
+					nRead = nReadLit;
+				}
+				else
+				{
+#if LOCAL_SHADOW
+					this.inBufPos = inBufPos;
+#endif
+					nRead = ReadCore( buffer, offset, nReadLit );
+#if LOCAL_SHADOW
+					inBufPos = this.inBufPos;
+					inBufEnd = this.inBufEnd;
+#endif
+#if CHECK_EOF
+					if( nRead == 0 )
+						goto finish;
+#endif
+				}
+
+				offset += nRead;
+				nToRead -= nRead;
+
+				litLen -= nRead;
+
+				if( litLen != 0 )
+					goto copyLiteral;
+			}
+
+			if( nToRead == 0 )
+				goto finish;
+
+			phase = DecodePhase.ReadOffset;
+			goto readOffset;
+
+		readOffset:
+			if( inBufPos + 1 < inBufEnd )
+			{
+				matDst = (decBuf[inBufPos + 1] << 8) | decBuf[inBufPos];
+				inBufPos += 2;
+			}
+			else
+			{
+#if LOCAL_SHADOW
+				this.inBufPos = inBufPos;
+#endif
+				matDst = ReadOffsetCore();
+#if LOCAL_SHADOW
+				inBufPos = this.inBufPos;
+				inBufEnd = this.inBufEnd;
+#endif
+#if CHECK_EOF
+				if( matDst == -1 )
+					goto finish;
+#endif
+			}
+
+			if( matLen == 15 + 4 )
+			{
+				phase = DecodePhase.ReadExMatchLength;
+				goto readExMatchLength;
+			}
+			else
+			{
+				phase = DecodePhase.CopyMatch;
+				goto copyMatch;
+			}
+
+		readExMatchLength:
+			int exMatLen;
+			if( inBufPos < inBufEnd )
+			{
+				exMatLen = decBuf[inBufPos++];
+			}
+			else
+			{
+#if LOCAL_SHADOW
+				this.inBufPos = inBufPos;
+#endif
+				exMatLen = ReadByteCore();
+#if LOCAL_SHADOW
+				inBufPos = this.inBufPos;
+				inBufEnd = this.inBufEnd;
+#endif
+#if CHECK_EOF
+				if( exMatLen == -1 )
+					goto finish;
+#endif
+			}
+
+			matLen += exMatLen;
+			if( exMatLen == 255 )
+				goto readExMatchLength;
+
+			phase = DecodePhase.CopyMatch;
+			goto copyMatch;
+
+		copyMatch:
+			int nCpyMat = matLen < nToRead ? matLen : nToRead;
+			if( nCpyMat != 0 )
+			{
+				nRead = count - nToRead;
+
+				int bufDst = matDst - nRead;
+				if( bufDst > 0 )
+				{
+					//offset is fairly far back, we need to pull from the buffer
+
+					int bufSrc = decodeBufferPos - bufDst;
+					if( bufSrc < 0 )
+						bufSrc += DecBufLen;
+					int bufCnt = bufDst < nCpyMat ? bufDst : nCpyMat;
+
+					for( int c = bufCnt; c-- != 0; )
+						buffer[offset++] = decBuf[bufSrc++ & DecBufMask];
+				}
+				else
+				{
+					bufDst = 0;
+				}
+
+				int sOfs = offset - matDst;
+				for( int i = bufDst; i < nCpyMat; i++ )
+					buffer[offset++] = buffer[sOfs++];
+
+				nToRead -= nCpyMat;
+				matLen -= nCpyMat;
+			}
+
+			if( nToRead == 0 )
+				goto finish;
+
+			phase = DecodePhase.ReadToken;
+			goto readToken;
+
+		finish:
+			nRead = count - nToRead;
+
+			int nToBuf = nRead < DecBufLen ? nRead : DecBufLen;
+			int repPos = offset - nToBuf;
+
+			if( nToBuf == DecBufLen )
+			{
+				Buffer.BlockCopy( buffer, repPos, decBuf, 0, DecBufLen );
+				decodeBufferPos = 0;
+			}
+			else
+			{
+				int decPos = decodeBufferPos;
+
+				while( nToBuf-- != 0 )
+					decBuf[decPos++ & DecBufMask] = buffer[repPos++];
+
+				decodeBufferPos = decPos & DecBufMask;
+			}
+
+#if LOCAL_SHADOW
+			this.phase = phase;
+			this.inBufPos = inBufPos;
+#endif
+			return nRead;
+		}
+
+		private int ReadByteCore()
+		{
+			var buf = decodeBuffer;
+
+			if( inBufPos == inBufEnd )
+			{
+				int nRead = input.Read( buf, DecBufLen,
+					InBufLen < inputLength ? InBufLen : (int)inputLength );
+
+#if CHECK_EOF
+				if( nRead == 0 )
+					return -1;
+#endif
+
+				inputLength -= nRead;
+
+				inBufPos = DecBufLen;
+				inBufEnd = DecBufLen + nRead;
+			}
+
+			return buf[inBufPos++];
+		}
+
+		private int ReadOffsetCore()
+		{
+			var buf = decodeBuffer;
+
+			if( inBufPos == inBufEnd )
+			{
+				int nRead = input.Read( buf, DecBufLen,
+					InBufLen < inputLength ? InBufLen : (int)inputLength );
+
+#if CHECK_EOF
+				if( nRead == 0 )
+					return -1;
+#endif
+
+				inputLength -= nRead;
+
+				inBufPos = DecBufLen;
+				inBufEnd = DecBufLen + nRead;
+			}
+
+			if( inBufEnd - inBufPos == 1 )
+			{
+				buf[DecBufLen] = buf[inBufPos];
+
+				int nRead = input.Read( buf, DecBufLen + 1,
+					InBufLen - 1 < inputLength ? InBufLen - 1 : (int)inputLength );
+
+#if CHECK_EOF
+				if( nRead == 0 )
+				{
+					inBufPos = DecBufLen;
+					inBufEnd = DecBufLen + 1;
+
+					return -1;
+				}
+#endif
+
+				inputLength -= nRead;
+
+				inBufPos = DecBufLen;
+				inBufEnd = DecBufLen + nRead + 1;
+			}
+
+			int ret = (buf[inBufPos + 1] << 8) | buf[inBufPos];
+			inBufPos += 2;
+
+			return ret;
+		}
+
+		private int ReadCore( byte[] buffer, int offset, int count )
+		{
+			int nToRead = count;
+
+			var buf = decodeBuffer;
+			int inBufLen = inBufEnd - inBufPos;
+
+			int fromBuf = nToRead < inBufLen ? nToRead : inBufLen;
+			if( fromBuf != 0 )
+			{
+				var bufPos = inBufPos;
+
+				for( int c = fromBuf; c-- != 0; )
+					buffer[offset++] = buf[bufPos++];
+
+				inBufPos = bufPos;
+				nToRead -= fromBuf;
+			}
+
+			if( nToRead != 0 )
+			{
+				int nRead;
+
+				if( nToRead >= InBufLen )
+				{
+					nRead = input.Read( buffer, offset,
+						nToRead < inputLength ? nToRead : (int)inputLength );
+					nToRead -= nRead;
+				}
+				else
+				{
+					nRead = input.Read( buf, DecBufLen,
+						InBufLen < inputLength ? InBufLen : (int)inputLength );
+
+					inBufPos = DecBufLen;
+					inBufEnd = DecBufLen + nRead;
+
+					fromBuf = nToRead < nRead ? nToRead : nRead;
+
+					var bufPos = inBufPos;
+
+					for( int c = fromBuf; c-- != 0; )
+						buffer[offset++] = buf[bufPos++];
+
+					inBufPos = bufPos;
+					nToRead -= fromBuf;
+				}
+
+				inputLength -= nRead;
+			}
+
+			return count - nToRead;
+		}
+
+		#region Stream internals
+
+		public override bool CanRead
+		{
+			get { return true; }
+		}
+
+		public override bool CanSeek
+		{
+			get { return false; }
+		}
+
+		public override bool CanWrite
+		{
+			get { return false; }
+		}
+
+		public override void Flush()
+		{
+		}
+
+		public override long Length
+		{
+			get { throw new NotSupportedException(); }
+		}
+
+		public override long Position
+		{
+			get { throw new NotSupportedException(); }
+			set { throw new NotSupportedException(); }
+		}
+
+		public override long Seek( long offset, SeekOrigin origin )
+		{
+			throw new NotSupportedException();
+		}
+
+		public override void SetLength( long value )
+		{
+			throw new NotSupportedException();
+		}
+
+		public override void Write( byte[] buffer, int offset, int count )
+		{
+			throw new NotSupportedException();
+		}
+
+		#endregion
+	}
+}
diff --git a/MonoGame.Framework/Utilities/LzxStream/LzxDecoderStream.cs b/MonoGame.Framework/Utilities/LzxStream/LzxDecoderStream.cs
new file mode 100644
index 00000000000..8487aeb04cb
--- /dev/null
+++ b/MonoGame.Framework/Utilities/LzxStream/LzxDecoderStream.cs
@@ -0,0 +1,148 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.IO;
+using Microsoft.Xna.Framework.Content;
+
+namespace MonoGame.Utilities
+{
+    internal class LzxDecoderStream : Stream
+    {
+        LzxDecoder dec;
+        MemoryStream decompressedStream;
+
+        public LzxDecoderStream(Stream input, int decompressedSize, int compressedSize)
+        {
+            dec = new LzxDecoder(16);
+
+            // TODO: Rewrite using block decompression like Lz4DecoderStream
+            Decompress(input, decompressedSize, compressedSize);
+        }
+
+        // Decompress into MemoryStream
+        private void Decompress(Stream stream, int decompressedSize, int compressedSize)
+        {
+            //thanks to ShinAli (https://bitbucket.org/alisci01/xnbdecompressor)
+            // default window size for XNB encoded files is 64Kb (need 16 bits to represent it)
+            decompressedStream = new MemoryStream(decompressedSize);
+            long startPos = stream.Position;
+            long pos = startPos;
+            
+            while (pos - startPos < compressedSize)
+            {
+                // the compressed stream is seperated into blocks that will decompress
+                // into 32Kb or some other size if specified.
+                // normal, 32Kb output blocks will have a short indicating the size
+                // of the block before the block starts
+                // blocks that have a defined output will be preceded by a byte of value
+                // 0xFF (255), then a short indicating the output size and another
+                // for the block size
+                // all shorts for these cases are encoded in big endian order
+                int hi = stream.ReadByte();
+                int lo = stream.ReadByte();
+                int block_size = (hi << 8) | lo;
+                int frame_size = 0x8000; // frame size is 32Kb by default
+                                         // does this block define a frame size?
+                if (hi == 0xFF)
+                {
+                    hi = lo;
+                    lo = (byte)stream.ReadByte();
+                    frame_size = (hi << 8) | lo;
+                    hi = (byte)stream.ReadByte();
+                    lo = (byte)stream.ReadByte();
+                    block_size = (hi << 8) | lo;
+                    pos += 5;
+                }
+                else
+                    pos += 2;
+
+                // either says there is nothing to decode
+                if (block_size == 0 || frame_size == 0)
+                    break;
+
+                dec.Decompress(stream, block_size, decompressedStream, frame_size);
+                pos += block_size;
+
+                // reset the position of the input just incase the bit buffer
+                // read in some unused bytes
+                stream.Seek(pos, SeekOrigin.Begin);
+            }
+
+            if (decompressedStream.Position != decompressedSize)
+            {
+                throw new ContentLoadException("Decompression failed.");
+            }
+
+            decompressedStream.Seek(0, SeekOrigin.Begin);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            base.Dispose(disposing);
+            if(disposing)
+            {                
+                decompressedStream.Dispose();
+            }            
+            dec = null;
+            decompressedStream = null;
+        }
+
+        #region Stream internals
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            return decompressedStream.Read(buffer, offset, count);
+        }
+
+        public override bool CanRead
+        {
+            get { return true; }
+        }
+
+
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        public override bool CanWrite
+        {
+            get { return false; }
+        }
+
+        public override void Flush()
+        {
+        }
+
+        public override long Length
+        {
+            get { throw new NotSupportedException(); }
+        }
+
+        public override long Position
+        {
+            get { throw new NotSupportedException(); }
+            set { throw new NotSupportedException(); }
+        }
+
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotImplementedException();
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Utilities/Png/PngCommon.cs b/MonoGame.Framework/Utilities/Png/PngCommon.cs
new file mode 100644
index 00000000000..f6a7d803a0c
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Png/PngCommon.cs
@@ -0,0 +1,667 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Collections;
+using System.Text;
+using Microsoft.Xna.Framework;
+
+namespace MonoGame.Utilities.Png
+{
+    internal class Palette
+    {
+        private IList<Color> colors;
+
+        internal Palette()
+        {
+            colors = new List<Color>();
+        }
+
+        internal Color this[int index]
+        {
+            get
+            {
+                return colors[index];
+            }
+        }
+
+        internal void AddColor(Color color)
+        {
+            colors.Add(color);
+        }
+
+        internal void AddAlphaToColorAtIndex(int colorIndex, byte alpha)
+        {
+            var oldColor = colors[colorIndex];
+
+            colors[colorIndex] = new Color(oldColor.R, oldColor.G, oldColor.B, alpha);
+        }
+
+        internal void AddAlphaToColors(IList<byte> alphas)
+        {
+            for (int i = 0; i < alphas.Count; i++)
+            {
+                AddAlphaToColorAtIndex(i, alphas[i]);
+            }
+        }
+    }
+
+    #region Chunks
+
+    internal class PngChunk
+    {
+        internal PngChunk()
+        {
+            this.Data = new byte[0];
+        }
+
+        /// <summary>
+        /// Length of Data field
+        /// </summary>
+        internal uint Length
+        {
+            get;
+            set;
+        }
+
+        internal string Type
+        {
+            get;
+            set;
+        }
+
+        private bool Ancillary
+        {
+            get;
+            set;
+        }
+
+        private bool Private
+        {
+            get;
+            set;
+        }
+
+        private bool Reserved
+        {
+            get;
+            set;
+        }
+
+        private bool SafeToCopy
+        {
+            get;
+            set;
+        }
+
+        internal byte[] Data
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// CRC of both Type and Data fields, but not Length field
+        /// </summary>
+        internal uint Crc
+        {
+            get;
+            set;
+        }
+
+        internal virtual void Decode(byte[] chunkBytes)
+        {
+            var chunkBytesList = chunkBytes.ToList();
+
+            this.Length = chunkBytesList.GetRange(0, 4).ToArray().ToUInt();
+            DecodeType(chunkBytesList.GetRange(4, 4).ToArray());
+            this.Data = chunkBytesList.GetRange(8, (int)this.Length).ToArray();
+            this.Crc = chunkBytesList.GetRange((int)(8 + this.Length), 4).ToArray().ToUInt();
+
+            if (CrcCheck() == false)
+            {
+                throw new Exception("CRC check failed.");
+            }
+        }
+
+        internal virtual byte[] Encode()
+        {
+            var result = new List<byte>();
+
+            uint dataLength = (uint)this.Data.Length;
+            uint dataCrc = PngCrc.Calculate(InputToCrcCheck());
+
+            result.AddRange(dataLength.ToByteArray());
+            result.AddRange(GetChunkTypeBytes(this.Type));
+            result.AddRange(this.Data);
+            result.AddRange(dataCrc.ToByteArray());
+
+            return result.ToArray();
+        }
+
+        private void DecodeType(byte[] typeBytes)
+        {
+            this.Type = PngChunk.GetChunkTypeString(typeBytes);
+
+            var bitArray = new BitArray(typeBytes);
+
+            this.Ancillary = bitArray[4];
+            this.Private = bitArray[9];
+            this.Reserved = bitArray[14];
+            this.SafeToCopy = bitArray[19];
+        }
+
+        private bool CrcCheck()
+        {
+            var crcInputBytes = InputToCrcCheck();
+
+            return (PngCrc.Calculate(crcInputBytes) == this.Crc);
+        }
+
+        private byte[] InputToCrcCheck()
+        {
+            byte[] chunkTypeBytes = GetChunkTypeBytes(this.Type);
+            return chunkTypeBytes.Concat(this.Data).ToArray();
+        }
+
+        internal static string GetChunkTypeString(byte[] chunkTypeBytes)
+        {
+            return Encoding.UTF8.GetString(chunkTypeBytes, 0, chunkTypeBytes.Length);
+        }
+
+        private static byte[] GetChunkTypeBytes(string chunkTypeString)
+        {
+            return Encoding.UTF8.GetBytes(chunkTypeString);
+        }
+    }
+
+    internal class HeaderChunk : PngChunk
+    {
+        private static byte[] pngSignature = new byte[] { 137, 80, 78, 71, 13, 10, 26, 10 };
+        
+        internal HeaderChunk()
+        {
+            base.Type = "IHDR";
+        }
+
+        internal uint Width
+        {
+            get;
+            set;
+        }
+
+        internal uint Height
+        {
+            get;
+            set;
+        }
+
+        internal byte BitDepth
+        {
+            get;
+            set;
+        }
+
+        internal ColorType ColorType
+        {
+            get;
+            set;
+        }
+
+        internal byte CompressionMethod
+        {
+            get;
+            set;
+        }
+
+        internal byte FilterMethod
+        {
+            get;
+            set;
+        }
+
+        internal byte InterlaceMethod
+        {
+            get;
+            set;
+        }
+
+        internal static byte[] PngSignature
+        {
+            get { return pngSignature; }
+        }
+
+        internal override void Decode(byte[] chunkBytes)
+        {
+            base.Decode(chunkBytes);
+            var chunkData = base.Data;
+
+            this.Width = chunkData.Take(4).ToArray().ToUInt();
+            this.Height = chunkData.Skip(4).Take(4).ToArray().ToUInt();
+            this.BitDepth = chunkData.Skip(8).First();
+            this.ColorType = (ColorType)chunkData.Skip(9).First();
+            this.CompressionMethod = chunkData.Skip(10).First();
+            this.FilterMethod = chunkData.Skip(11).First();
+            this.InterlaceMethod = chunkData.Skip(12).First();
+
+            if (this.BitDepth < 8)
+            {
+                throw new Exception(String.Format("Bit depth less than 8 bits per sample is unsupported.  Image bit depth is {0} bits per sample.", this.BitDepth));
+            }
+        }
+
+        internal override byte[] Encode()
+        {
+            var chunkData = new List<byte>();
+
+            chunkData.AddRange(this.Width.ToByteArray().ToList());
+            chunkData.AddRange(this.Height.ToByteArray().ToList());
+            chunkData.Add(this.BitDepth);
+            chunkData.Add((byte)this.ColorType);
+            chunkData.Add(this.CompressionMethod);
+            chunkData.Add(this.FilterMethod);
+            chunkData.Add(this.InterlaceMethod);
+
+            base.Data = chunkData.ToArray();
+
+            return base.Encode();
+        }
+    }
+
+    internal class PaletteChunk : PngChunk
+    {
+        internal PaletteChunk()
+        {
+            base.Type = "PLTE";
+            this.Palette = new Palette();
+        }
+
+        internal Palette Palette
+        {
+            get;
+            set;
+        }
+
+        internal override void Decode(byte[] chunkBytes)
+        {
+            base.Decode(chunkBytes);
+            var chunkData = base.Data;
+
+            if (chunkData.Length % 3 != 0)
+            {
+                throw new Exception("Malformed palette chunk - length not multiple of 3.");
+            }
+
+            for (int i = 0; i < chunkData.Length / 3; i++)
+            {
+                byte red = chunkData.Skip(3 * i).Take(1).First();
+                byte green = chunkData.Skip((3 * i) + 1).Take(1).First();
+                byte blue = chunkData.Skip((3 * i) + 2).Take(1).First();
+
+                this.Palette.AddColor(new Color(red, green, blue));
+            }
+        }
+    }
+
+    internal class TransparencyChunk : PngChunk
+    {
+        internal TransparencyChunk()
+        {
+            base.Type = "tRNS";
+            this.PaletteTransparencies = new List<byte>();
+        }
+
+        internal IList<byte> PaletteTransparencies
+        {
+            get;
+            set;
+        }
+
+        internal override void Decode(byte[] chunkBytes)
+        {
+            base.Decode(chunkBytes);
+            var chunkData = base.Data;
+
+            this.PaletteTransparencies = chunkData.ToArray();
+        }
+
+        internal override byte[] Encode()
+        {
+            var chunkData = new List<byte>();
+
+
+            base.Data = chunkData.ToArray();
+
+            return base.Encode();
+        }
+    }
+
+    internal class DataChunk : PngChunk
+    {
+        internal DataChunk()
+        {
+            base.Type = "IDAT";
+        }
+    }
+
+    internal class EndChunk : PngChunk
+    {
+        internal EndChunk()
+        {
+            base.Type = "IEND";
+        }
+    }
+
+    #endregion
+    
+    #region Enumerations
+
+    internal enum ColorType
+    {
+        Grayscale = 0,
+        Rgb = 2,
+        Palette = 3,
+        GrayscaleWithAlpha = 4,
+        RgbWithAlpha = 6
+    }
+
+    internal enum FilterType
+    {
+        None = 0,
+        Sub = 1,
+        Up = 2,
+        Average = 3,
+        Paeth = 4
+    }
+
+    #endregion
+
+    #region Filters
+
+    internal static class NoneFilter
+    {
+        internal static byte[] Decode(byte[] scanline)
+        {
+            return scanline;
+        }
+
+        internal static byte[] Encode(byte[] scanline)
+        {
+            var encodedScanline = new byte[scanline.Length + 1];
+
+            encodedScanline[0] = (byte)FilterType.None;
+            scanline.CopyTo(encodedScanline, 1);
+
+            return encodedScanline;
+        }
+    }
+
+    internal static class SubFilter
+    {
+        internal static byte[] Decode(byte[] scanline, int bytesPerPixel)
+        {
+            byte[] result = new byte[scanline.Length];
+
+            for (int x = 1; x < scanline.Length; x++)
+            {
+                byte priorRawByte = (x - bytesPerPixel < 1) ? (byte)0 : result[x - bytesPerPixel];
+
+                result[x] = (byte)((scanline[x] + priorRawByte) % 256);
+            }
+
+            return result;
+        }
+
+        internal static byte[] Encode(byte[] scanline, int bytesPerPixel)
+        {
+            var encodedScanline = new byte[scanline.Length + 1];
+
+            encodedScanline[0] = (byte)FilterType.Sub;
+
+            for (int x = 0; x < scanline.Length; x++)
+            {
+                byte priorRawByte = (x - bytesPerPixel < 0) ? (byte)0 : scanline[x - bytesPerPixel];
+
+                encodedScanline[x + 1] = (byte)((scanline[x] - priorRawByte) % 256);
+            }
+
+            return encodedScanline;
+        }
+    }
+
+    internal static class UpFilter
+    {
+        internal static byte[] Decode(byte[] scanline, byte[] previousScanline)
+        {
+            byte[] result = new byte[scanline.Length];
+
+            for (int x = 1; x < scanline.Length; x++)
+            {
+                byte above = previousScanline[x];
+
+                result[x] = (byte)((scanline[x] + above) % 256);
+            }
+
+            return result;
+        }
+
+        internal static byte[] Encode(byte[] scanline, byte[] previousScanline)
+        {
+            var encodedScanline = new byte[scanline.Length + 1];
+
+            encodedScanline[0] = (byte)FilterType.Up;
+
+            for (int x = 0; x < scanline.Length; x++)
+            {
+                byte above = previousScanline[x];
+
+                encodedScanline[x + 1] = (byte)((scanline[x] - above) % 256);
+            }
+
+            return encodedScanline;
+        }
+    }
+
+    internal static class AverageFilter
+    {
+        internal static byte[] Decode(byte[] scanline, byte[] previousScanline, int bytesPerPixel)
+        {
+            byte[] result = new byte[scanline.Length];
+
+            for (int x = 1; x < scanline.Length; x++)
+            {
+                byte left = (x - bytesPerPixel < 1) ? (byte)0 : result[x - bytesPerPixel];
+                byte above = previousScanline[x];
+
+                result[x] = (byte)((scanline[x] + Average(left, above)) % 256);
+            }
+
+            return result;
+        }
+
+        internal static byte[] Encode(byte[] scanline, byte[] previousScanline, int bytesPerPixel)
+        {
+            var encodedScanline = new byte[scanline.Length + 1];
+
+            encodedScanline[0] = (byte)FilterType.Average;
+
+            for (int x = 0; x < scanline.Length; x++)
+            {
+                byte left = (x - bytesPerPixel < 0) ? (byte)0 : scanline[x - bytesPerPixel];
+                byte above = previousScanline[x];
+
+                encodedScanline[x + 1] = (byte)((scanline[x] - Average(left, above)) % 256);
+            }
+
+            return encodedScanline;
+        }
+
+        private static int Average(byte left, byte above)
+        {
+            return Convert.ToInt32(Math.Floor((left + above) / 2.0));
+        }
+    }
+
+    internal static class PaethFilter
+    {
+        internal static byte[] Decode(byte[] scanline, byte[] previousScanline, int bytesPerPixel)
+        {
+            byte[] result = new byte[scanline.Length];
+
+            for (int x = 1; x < scanline.Length; x++)
+            {
+                byte left = (x - bytesPerPixel < 1) ? (byte)0 : result[x - bytesPerPixel];
+                byte above = previousScanline[x];
+                byte upperLeft = (x - bytesPerPixel < 1) ? (byte)0 : previousScanline[x - bytesPerPixel];
+
+                result[x] = (byte)((scanline[x] + PaethPredictor(left, above, upperLeft)) % 256);
+            }
+
+            return result;
+        }
+
+        internal static byte[] Encode(byte[] scanline, byte[] previousScanline, int bytesPerPixel)
+        {
+            var encodedScanline = new byte[scanline.Length + 1];
+
+            encodedScanline[0] = (byte)FilterType.Paeth;
+
+            for (int x = 0; x < scanline.Length; x++)
+            {
+                byte left = (x - bytesPerPixel < 0) ? (byte)0 : scanline[x - bytesPerPixel];
+                byte above = previousScanline[x];
+                byte upperLeft = (x - bytesPerPixel < 0) ? (byte)0 : previousScanline[x - bytesPerPixel];
+
+                encodedScanline[x + 1] = (byte)((scanline[x] - PaethPredictor(left, above, upperLeft)) % 256);
+            }
+
+            return encodedScanline;
+        }
+
+        private static int PaethPredictor(int a, int b, int c)
+        {
+            int p = a + b - c;
+            int pa = Math.Abs(p - a);
+            int pb = Math.Abs(p - b);
+            int pc = Math.Abs(p - c);
+
+            if ((pa <= pb) && (pa <= pc))
+            {
+                return a;
+            }
+            else
+            {
+                if (pb <= pc)
+                {
+                    return b;
+                }
+                else
+                {
+                    return c;
+                }
+            }
+        }
+    }
+
+    #endregion
+
+    internal static class PngCrc
+    {
+        // table of CRCs of all 8-bit messages
+        private static uint[] crcTable = null;
+
+        static PngCrc()
+        {
+            BuildCrcTable();
+        }
+
+        /// <summary>
+        /// Build CRC lookup table for performance (once-off)
+        /// </summary>
+        private static void BuildCrcTable()
+        {
+            crcTable = new uint[256];
+
+            uint c, n, k;
+
+            for (n = 0; n < 256; n++)
+            {
+                c = n;
+
+                for (k = 0; k < 8; k++)
+                {
+                    if ((c & 1) > 0)
+                    {
+                        c = 0xedb88320 ^ (c >> 1);
+                    }
+                    else
+                    {
+                        c = c >> 1;
+                    }
+                }
+
+                crcTable[n] = c;
+            }
+        }
+
+        internal static uint Calculate(byte[] bytes)
+        {
+            uint c = 0xffffffff;
+
+            int n;
+
+            if (crcTable == null)
+            {
+                BuildCrcTable();
+            }
+
+            for (n = 0; n < bytes.Length; n++)
+            {
+                c = crcTable[(c ^ bytes[n]) & 0xff] ^ (c >> 8);
+            }
+
+            return c ^ 0xffffffff;
+        }
+    }
+
+    internal static class Extensions
+    {
+        internal static uint ToUInt(this byte[] bytes)
+        {
+            byte[] input;
+
+            if (BitConverter.IsLittleEndian)
+            {
+                input = ReverseByteArray(bytes);
+            }
+            else
+            {
+                input = bytes;
+            }
+
+            return BitConverter.ToUInt32(input, 0);
+        }
+
+        internal static byte[] ToByteArray(this uint integer)
+        {
+            byte[] output = BitConverter.GetBytes(integer);
+
+            if (BitConverter.IsLittleEndian)
+            {
+                return ReverseByteArray(output);
+            }
+            else
+            {
+                return output;
+            }
+        }
+
+        private static byte[] ReverseByteArray(byte[] byteArray)
+        {
+            return (byte[])byteArray.Reverse().ToArray();
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/Png/PngReader.cs b/MonoGame.Framework/Utilities/Png/PngReader.cs
new file mode 100644
index 00000000000..978eb907a99
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Png/PngReader.cs
@@ -0,0 +1,347 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.IO;
+using System.Linq;
+using System.Text;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework;
+using MonoGame.Utilities;
+
+namespace MonoGame.Utilities.Png
+{
+    public class PngReader
+    {
+        private int width;
+        private int height;
+        private int bitsPerSample;
+        private int bytesPerSample;
+        private int bytesPerPixel;
+        private int bytesPerScanline;
+        private IList<PngChunk> chunks;
+        private IList<PngChunk> dataChunks;
+        private ColorType colorType;
+        private Palette palette;
+        private Texture2D texture;
+        private Color[] data;
+        
+        public PngReader()
+        {
+            chunks = new List<PngChunk>();
+            dataChunks = new List<PngChunk>();
+        }
+
+        public Texture2D Read(Stream inputStream, GraphicsDevice graphicsDevice)
+        {
+            if (IsPngImage(inputStream) == false)
+            {
+                throw new Exception("File does not have PNG signature.");
+            }
+
+            inputStream.Position = 8;
+
+            while (inputStream.Position != inputStream.Length)
+            {
+                byte[] chunkDataLengthBytes = new byte[4];
+                inputStream.Read(chunkDataLengthBytes, 0, 4);
+                uint chunkDataLength = chunkDataLengthBytes.ToUInt();
+
+                inputStream.Position -= 4;
+
+                byte[] chunkBytes = new byte[12 + chunkDataLength];
+                inputStream.Read(chunkBytes, 0, (int)(12 + chunkDataLength));
+
+                ProcessChunk(chunkBytes);
+            }
+
+            UnpackDataChunks();
+
+            texture = new Texture2D(graphicsDevice, width, height, false, SurfaceFormat.Color);
+            texture.SetData<Color>(data);
+
+            return texture;
+        }
+
+        public static bool IsPngImage(Stream stream)
+        {
+            stream.Position = 0;
+            
+            byte[] signature = new byte[8];
+            stream.Read(signature, 0, 8);
+
+            bool result = signature.SequenceEqual(HeaderChunk.PngSignature);
+
+            stream.Position = 0;
+
+            return result;
+        }
+
+        private void ProcessChunk(byte[] chunkBytes)
+        {
+            string chunkType = PngChunk.GetChunkTypeString(chunkBytes.Skip(4).Take(4).ToArray());
+
+            switch (chunkType)
+            {
+                case "IHDR":
+
+                    var headerChunk = new HeaderChunk();
+                    headerChunk.Decode(chunkBytes);
+                    width = (int)headerChunk.Width;
+                    height = (int)headerChunk.Height;
+                    bitsPerSample = (int)headerChunk.BitDepth;
+                    colorType = headerChunk.ColorType;
+                    chunks.Add(headerChunk);
+
+                    break;
+
+                case "PLTE":
+
+                    var paletteChunk = new PaletteChunk();
+                    paletteChunk.Decode(chunkBytes);
+                    palette = paletteChunk.Palette;
+                    chunks.Add(paletteChunk);
+
+                    break;
+
+                case "tRNS":
+
+                    var transparencyChunk = new TransparencyChunk();
+                    transparencyChunk.Decode(chunkBytes);
+                    palette.AddAlphaToColors(transparencyChunk.PaletteTransparencies);
+                    break;
+
+                case "IDAT":
+
+                    var dataChunk = new DataChunk();
+                    dataChunk.Decode(chunkBytes);
+                    dataChunks.Add(dataChunk);
+
+                    break;
+
+                default:
+                    break;
+            }
+        }
+
+        private void UnpackDataChunks()
+        {
+            var dataByteList = new List<byte>();
+
+            foreach (var dataChunk in dataChunks)
+            {
+                if (dataChunk.Type == "IDAT")
+                {
+                    dataByteList.AddRange(dataChunk.Data);
+                }
+            }
+
+            var compressedStream = new MemoryStream(dataByteList.ToArray());
+            var decompressedStream = new MemoryStream();
+
+            try
+            {
+                using (var deflateStream = new ZlibStream(compressedStream, CompressionMode.Decompress))
+                {
+                    deflateStream.CopyTo(decompressedStream);
+                }
+            }
+            catch (Exception exception)
+            {
+                throw new Exception("An error occurred during DEFLATE decompression.", exception);
+            }
+
+            var decompressedBytes = decompressedStream.ToArray();
+            var pixelData = DeserializePixelData(decompressedBytes);
+
+            DecodePixelData(pixelData);
+        }
+
+        private byte[][] DeserializePixelData(byte[] pixelData)
+        {
+            bytesPerPixel = CalculateBytesPerPixel();
+            bytesPerSample = bitsPerSample / 8;
+            bytesPerScanline = (bytesPerPixel * width) + 1;
+            int scanlineCount = pixelData.Length / bytesPerScanline;
+
+            if (pixelData.Length % bytesPerScanline != 0)
+            {
+                throw new Exception("Malformed pixel data - total length of pixel data not multiple of ((bytesPerPixel * width) + 1)");
+            }
+
+            var result = new byte[scanlineCount][];
+
+            for (int y = 0; y < scanlineCount; y++)
+            {
+                result[y] = new byte[bytesPerScanline];
+                
+                for (int x = 0; x < bytesPerScanline; x++)
+                {
+                    result[y][x] = pixelData[y * bytesPerScanline + x];
+                }
+            }
+            
+            return result;
+        }
+
+        private void DecodePixelData(byte[][] pixelData)
+        {
+            data = new Color[width * height];
+            
+            byte[] previousScanline = new byte[bytesPerScanline];
+
+            for (int y = 0; y < height; y++)
+            {
+                var scanline = pixelData[y];
+
+                FilterType filterType = (FilterType)scanline[0];
+                byte[] defilteredScanline;
+
+                switch (filterType)
+                {
+                    case FilterType.None:
+
+                        defilteredScanline = NoneFilter.Decode(scanline);
+
+                        break;
+
+                    case FilterType.Sub:
+
+                        defilteredScanline = SubFilter.Decode(scanline, bytesPerPixel);
+
+                        break;
+
+                    case FilterType.Up:
+
+                        defilteredScanline = UpFilter.Decode(scanline, previousScanline);
+
+                        break;
+
+                    case FilterType.Average:
+
+                        defilteredScanline = AverageFilter.Decode(scanline, previousScanline, bytesPerPixel);
+
+                        break;
+
+                    case FilterType.Paeth:
+
+                        defilteredScanline = PaethFilter.Decode(scanline, previousScanline, bytesPerPixel);
+
+                        break;
+
+                    default:
+                        throw new Exception("Unknown filter type.");
+                }
+
+                previousScanline = defilteredScanline;
+                ProcessDefilteredScanline(defilteredScanline, y);
+            }
+        }
+
+        private void ProcessDefilteredScanline(byte[] defilteredScanline, int y)
+        {
+            switch (colorType)
+            {
+                case ColorType.Grayscale:
+
+                    for (int x = 0; x < width; x++)
+                    {
+                        int offset = 1 + (x * bytesPerPixel);
+
+                        byte intensity = defilteredScanline[offset];
+
+                        data[(y * width) + x] = new Color(intensity, intensity, intensity);
+                    }
+
+                    break;
+
+                case ColorType.GrayscaleWithAlpha:
+
+                    for (int x = 0; x < width; x++)
+                    {
+                        int offset = 1 + (x * bytesPerPixel);
+
+                        byte intensity = defilteredScanline[offset];
+                        byte alpha = defilteredScanline[offset + bytesPerSample];
+
+                        data[(y * width) + x] = new Color(intensity, intensity, intensity, alpha);
+                    }
+
+                    break;
+
+                case ColorType.Palette:
+
+                    for (int x = 0; x < width; x++)
+                    {
+                        var pixelColor = palette[defilteredScanline[x + 1]];
+
+                        data[(y * width) + x] = pixelColor;
+                    }
+
+                    break;
+
+                case ColorType.Rgb:
+
+                    for (int x = 0; x < width; x++)
+                    {
+                        int offset = 1 + (x * bytesPerPixel);
+                        
+                        int red = defilteredScanline[offset];
+                        int green = defilteredScanline[offset + bytesPerSample];
+                        int blue = defilteredScanline[offset + 2 * bytesPerSample];
+
+                        data[(y * width) + x] = new Color(red, green, blue);
+                    }
+
+                    break;
+
+                case ColorType.RgbWithAlpha:
+
+                    for (int x = 0; x < width; x++)
+                    {
+                        int offset = 1 + (x * bytesPerPixel);
+
+                        int red = defilteredScanline[offset];
+                        int green = defilteredScanline[offset + bytesPerSample];
+                        int blue = defilteredScanline[offset + 2 * bytesPerSample];
+                        int alpha = defilteredScanline[offset + 3 * bytesPerSample];
+
+                        data[(y * width) + x] = new Color(red, green, blue, alpha);
+                    }
+
+                    break;
+
+                default:
+                    break;
+            }
+        }
+
+        private int CalculateBytesPerPixel()
+        {
+            switch (colorType)
+            {
+                case ColorType.Grayscale:
+                    return bitsPerSample / 8;
+
+                case ColorType.GrayscaleWithAlpha:
+                    return (2 * bitsPerSample) / 8;
+
+                case ColorType.Palette:
+                    return bitsPerSample / 8;
+
+                case ColorType.Rgb:
+                    return (3 * bitsPerSample) / 8;
+
+                case ColorType.RgbWithAlpha:
+                    return (4 * bitsPerSample) / 8;
+
+                default:
+                    throw new Exception("Unknown color type.");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/Utilities/Png/PngWriter.cs b/MonoGame.Framework/Utilities/Png/PngWriter.cs
new file mode 100644
index 00000000000..5788b79ff4e
--- /dev/null
+++ b/MonoGame.Framework/Utilities/Png/PngWriter.cs
@@ -0,0 +1,366 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework;
+using MonoGame.Utilities;
+using Microsoft.Xna.Framework.Graphics.PackedVector;
+
+namespace MonoGame.Utilities.Png
+{
+    public class PngWriter
+    {
+        private const int bitsPerSample = 8;
+        private ColorType colorType;
+        private Color[] colorData;
+        private int width;
+        private int height;
+
+        public PngWriter()
+        {
+            colorType = ColorType.RgbWithAlpha;
+        }
+
+        public void Write(Texture2D texture2D, Stream outputStream)
+        {
+            width = texture2D.Width;
+            height = texture2D.Height;
+
+            GetColorData(texture2D);
+
+            // write PNG signature
+            outputStream.Write(HeaderChunk.PngSignature, 0, HeaderChunk.PngSignature.Length);
+
+            // write header chunk
+            var headerChunk = new HeaderChunk();
+            headerChunk.Width = (uint)texture2D.Width;
+            headerChunk.Height = (uint)texture2D.Height;
+            headerChunk.BitDepth = 8;
+            headerChunk.ColorType = colorType;
+            headerChunk.CompressionMethod = 0;
+            headerChunk.FilterMethod = 0;
+            headerChunk.InterlaceMethod = 0;
+
+            var headerChunkBytes = headerChunk.Encode();
+            outputStream.Write(headerChunkBytes, 0, headerChunkBytes.Length);
+
+            // write data chunks
+            var encodedPixelData = EncodePixelData(texture2D);
+            var compressedPixelData = new MemoryStream();
+
+            try
+            {
+                using (var deflateStream = new ZlibStream(new MemoryStream(encodedPixelData), CompressionMode.Compress))
+                {
+                    deflateStream.CopyTo(compressedPixelData);
+                }
+            }
+            catch (Exception exception)
+            {
+                throw new Exception("An error occurred during DEFLATE compression.", exception);
+            }
+            
+            var dataChunk = new DataChunk();
+            dataChunk.Data = compressedPixelData.ToArray();
+            var dataChunkBytes = dataChunk.Encode();
+            outputStream.Write(dataChunkBytes, 0, dataChunkBytes.Length);
+
+            // write end chunk
+            var endChunk = new EndChunk();
+            var endChunkBytes = endChunk.Encode();
+            outputStream.Write(endChunkBytes, 0, endChunkBytes.Length);
+        }
+
+        private byte[] EncodePixelData(Texture2D texture2D)
+        {
+            List<byte[]> filteredScanlines = new List<byte[]>();
+
+            int bytesPerPixel = CalculateBytesPerPixel();
+            byte[] previousScanline = new byte[width * bytesPerPixel];
+
+            for (int y = 0; y < height; y++)
+            {
+                var rawScanline = GetRawScanline(y);
+
+                var filteredScanline = GetOptimalFilteredScanline(rawScanline, previousScanline, bytesPerPixel);
+
+                filteredScanlines.Add(filteredScanline);
+
+                previousScanline = rawScanline;
+            }
+
+            List<byte> result = new List<byte>();
+
+            foreach (var encodedScanline in filteredScanlines)
+            {
+                result.AddRange(encodedScanline);
+            }
+
+            return result.ToArray();
+        }
+
+        /// <summary>
+        /// Applies all PNG filters to the given scanline and returns the filtered scanline that is deemed
+        /// to be most compressible, using lowest total variation as proxy for compressibility.
+        /// </summary>
+        /// <param name="rawScanline"></param>
+        /// <param name="previousScanline"></param>
+        /// <param name="bytesPerPixel"></param>
+        /// <returns></returns>
+        private byte[] GetOptimalFilteredScanline(byte[] rawScanline, byte[] previousScanline, int bytesPerPixel)
+        {
+            var candidates = new List<Tuple<byte[], int>>();
+            
+            var sub = SubFilter.Encode(rawScanline, bytesPerPixel);
+            candidates.Add(new Tuple<byte[], int>(sub, CalculateTotalVariation(sub)));
+
+            var up = UpFilter.Encode(rawScanline, previousScanline);
+            candidates.Add(new Tuple<byte[], int>(up, CalculateTotalVariation(up)));
+
+            var average = AverageFilter.Encode(rawScanline, previousScanline, bytesPerPixel);
+            candidates.Add(new Tuple<byte[], int>(average, CalculateTotalVariation(average)));
+
+            var paeth = PaethFilter.Encode(rawScanline, previousScanline, bytesPerPixel);
+            candidates.Add(new Tuple<byte[], int>(paeth, CalculateTotalVariation(paeth)));
+
+            int lowestTotalVariation = Int32.MaxValue;
+            int lowestTotalVariationIndex = 0;
+
+            for (int i = 0; i < candidates.Count; i++)
+            {
+                if (candidates[i].Item2 < lowestTotalVariation)
+                {
+                    lowestTotalVariationIndex = i;
+                    lowestTotalVariation = candidates[i].Item2;
+                }
+            }
+
+            return candidates[lowestTotalVariationIndex].Item1;
+        }
+
+        /// <summary>
+        /// Calculates the total variation of given byte array.  Total variation is the sum of the absolute values of
+        /// neighbour differences.
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        private int CalculateTotalVariation(byte[] input)
+        {
+            int totalVariation = 0;
+
+            for (int i = 1; i < input.Length; i++)
+            {
+                totalVariation += Math.Abs(input[i] - input[i - 1]);
+            }
+
+            return totalVariation;
+        }
+
+        private byte[] GetRawScanline(int y)
+        {
+            var rawScanline = new byte[4 * width];
+            
+            for (int x = 0; x < width; x++)
+            {
+                var color = colorData[(y * width) + x];
+
+                rawScanline[4 * x] = color.R;
+                rawScanline[(4 * x) + 1] = color.G;
+                rawScanline[(4 * x) + 2] = color.B;
+                rawScanline[(4 * x) + 3] = color.A;
+            }
+
+            return rawScanline;
+        }
+
+        private int CalculateBytesPerPixel()
+        {
+            switch (colorType)
+            {
+                case ColorType.Grayscale:
+                    return bitsPerSample / 8;
+
+                case ColorType.GrayscaleWithAlpha:
+                    return (2 * bitsPerSample) / 8;
+
+                case ColorType.Palette:
+                    return bitsPerSample / 8;
+
+                case ColorType.Rgb:
+                    return (3 * bitsPerSample) / 8;
+
+                case ColorType.RgbWithAlpha:
+                    return (4 * bitsPerSample) / 8;
+
+                default:
+                    return -1;
+            }
+        }
+
+        private void GetColorData(Texture2D texture2D)
+        {
+            int colorDataLength = texture2D.Width * texture2D.Height;
+            colorData = new Color[colorDataLength];
+
+            switch (texture2D.Format)
+            {
+                case SurfaceFormat.Single:
+                    var floatData = new float[colorDataLength];
+                    texture2D.GetData<float>(floatData);
+
+                    for (int i = 0; i < colorDataLength; i++)
+                    {
+                        float brightness = floatData[i];
+                        // Export as a greyscale image.
+                        colorData[i] = new Color(brightness, brightness, brightness);
+                    }
+                    break;
+
+                case SurfaceFormat.Color:
+                    texture2D.GetData<Color>(colorData);
+                    break;
+
+                case SurfaceFormat.Alpha8:
+                    var alpha8Data = new Alpha8[colorDataLength];
+                    texture2D.GetData<Alpha8>(alpha8Data);
+
+                    for (int i = 0; i < colorDataLength; i++)
+                    {
+                        colorData[i] = new Color(((IPackedVector)alpha8Data[i]).ToVector4());
+                    }
+
+                    break;
+                
+                case SurfaceFormat.Bgr565:
+                    var bgr565Data = new Bgr565[colorDataLength];
+                    texture2D.GetData<Bgr565>(bgr565Data);
+
+                    for (int i = 0; i < colorDataLength; i++)
+                    {
+                        colorData[i] = new Color(((IPackedVector)bgr565Data[i]).ToVector4());
+                    }
+
+                    break;
+
+                case SurfaceFormat.Bgra4444:
+                    var bgra4444Data = new Bgra4444[colorDataLength];
+                    texture2D.GetData<Bgra4444>(bgra4444Data);
+
+                    for (int i = 0; i < colorDataLength; i++)
+                    {
+                        colorData[i] = new Color(((IPackedVector)bgra4444Data[i]).ToVector4());
+                    }
+
+                    break;
+
+                case SurfaceFormat.Bgra5551:
+                    var bgra5551Data = new Bgra5551[colorDataLength];
+                    texture2D.GetData<Bgra5551>(bgra5551Data);
+
+                    for (int i = 0; i < colorDataLength; i++)
+                    {
+                        colorData[i] = new Color(((IPackedVector)bgra5551Data[i]).ToVector4());
+                    }
+                    break;
+
+                case SurfaceFormat.HalfSingle:
+                    var halfSingleData = new HalfSingle[colorDataLength];
+                    texture2D.GetData<HalfSingle>(halfSingleData);
+
+                    for (int i = 0; i < colorDataLength; i++)
+                    {
+                        colorData[i] = new Color(((IPackedVector)halfSingleData[i]).ToVector4());
+                    }
+
+                    break;
+
+                case SurfaceFormat.HalfVector2:
+                    var halfVector2Data = new HalfVector2[colorDataLength];
+                    texture2D.GetData<HalfVector2>(halfVector2Data);
+
+                    for (int i = 0; i < colorDataLength; i++)
+                    {
+                        colorData[i] = new Color(((IPackedVector)halfVector2Data[i]).ToVector4());
+                    }
+
+                    break;
+
+                case SurfaceFormat.HalfVector4:
+                    var halfVector4Data = new HalfVector4[colorDataLength];
+                    texture2D.GetData<HalfVector4>(halfVector4Data);
+
+                    for (int i = 0; i < colorDataLength; i++)
+                    {
+                        colorData[i] = new Color(((IPackedVector)halfVector4Data[i]).ToVector4());
+                    }
+
+                    break;
+
+                case SurfaceFormat.NormalizedByte2:
+                    var normalizedByte2Data = new NormalizedByte2[colorDataLength];
+                    texture2D.GetData<NormalizedByte2>(normalizedByte2Data);
+
+                    for (int i = 0; i < colorDataLength; i++)
+                    {
+                        colorData[i] = new Color(((IPackedVector)normalizedByte2Data[i]).ToVector4());
+                    }
+
+                    break;
+
+                case SurfaceFormat.NormalizedByte4:
+                    var normalizedByte4Data = new NormalizedByte4[colorDataLength];
+                    texture2D.GetData<NormalizedByte4>(normalizedByte4Data);
+
+                    for (int i = 0; i < colorDataLength; i++)
+                    {
+                        colorData[i] = new Color(((IPackedVector)normalizedByte4Data[i]).ToVector4());
+                    }
+
+                    break;
+
+                case SurfaceFormat.Rg32:
+                    var rg32Data = new Rg32[colorDataLength];
+                    texture2D.GetData<Rg32>(rg32Data);
+
+                    for (int i = 0; i < colorDataLength; i++)
+                    {
+                        colorData[i] = new Color(((IPackedVector)rg32Data[i]).ToVector4());
+                    }
+
+                    break;
+
+                case SurfaceFormat.Rgba64:
+                    var rgba64Data = new Rgba64[colorDataLength];
+                    texture2D.GetData<Rgba64>(rgba64Data);
+
+                    for (int i = 0; i < colorDataLength; i++)
+                    {
+                        colorData[i] = new Color(((IPackedVector)rgba64Data[i]).ToVector4());
+                    }
+
+                    break;
+
+                case SurfaceFormat.Rgba1010102:
+                    var rgba1010102Data = new Rgba1010102[colorDataLength];
+                    texture2D.GetData<Rgba1010102>(rgba1010102Data);
+
+                    for (int i = 0; i < colorDataLength; i++)
+                    {
+                        colorData[i] = new Color(((IPackedVector)rgba1010102Data[i]).ToVector4());
+                    }
+
+                    break;
+
+                default:
+                    throw new Exception("Texture surface format not supported");
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/ReflectionHelpers.Default.cs b/MonoGame.Framework/Utilities/ReflectionHelpers.Default.cs
new file mode 100644
index 00000000000..feb65b5e42b
--- /dev/null
+++ b/MonoGame.Framework/Utilities/ReflectionHelpers.Default.cs
@@ -0,0 +1,36 @@
+using System;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+namespace MonoGame.Utilities
+{
+    internal static partial class ReflectionHelpers
+    {
+        /// <summary>
+        /// Generics handler for Marshal.SizeOf
+        /// </summary>
+        internal static class SizeOf<T>
+        {
+            static int _sizeOf;
+
+            static SizeOf()
+            {
+                _sizeOf = Marshal.SizeOf<T>();
+            }
+
+            static public int Get()
+            {
+                return _sizeOf;
+            }
+        }
+
+        /// <summary>
+        /// Fallback handler for Marshal.SizeOf(type)
+        /// </summary>
+        internal static int ManagedSizeOf(Type type)
+        {
+            return Marshal.SizeOf(type);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/ReflectionHelpers.Legacy.cs b/MonoGame.Framework/Utilities/ReflectionHelpers.Legacy.cs
new file mode 100644
index 00000000000..69992c0c606
--- /dev/null
+++ b/MonoGame.Framework/Utilities/ReflectionHelpers.Legacy.cs
@@ -0,0 +1,37 @@
+using System;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+namespace MonoGame.Utilities
+{
+    internal static partial class ReflectionHelpers
+    {
+        /// <summary>
+        /// Generics handler for Marshal.SizeOf
+        /// </summary>
+        internal static class SizeOf<T>
+        {
+            static int _sizeOf;
+
+            static SizeOf()
+            {
+                var type = typeof(T);
+                _sizeOf = Marshal.SizeOf(type);
+            }
+
+            static public int Get()
+            {
+                return _sizeOf;
+            }
+        }
+
+        /// <summary>
+        /// Fallback handler for Marshal.SizeOf(type)
+        /// </summary>
+        internal static int ManagedSizeOf(Type type)
+        {
+            return Marshal.SizeOf(type);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/ReflectionHelpers.cs b/MonoGame.Framework/Utilities/ReflectionHelpers.cs
new file mode 100644
index 00000000000..b2f4a20f6ad
--- /dev/null
+++ b/MonoGame.Framework/Utilities/ReflectionHelpers.cs
@@ -0,0 +1,178 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Reflection;
+
+namespace MonoGame.Utilities
+{
+    internal static partial class ReflectionHelpers
+    {
+        public static bool IsValueType(Type targetType)
+        {
+            if (targetType == null)
+            {
+                throw new NullReferenceException("Must supply the targetType parameter");
+            }
+#if NET45            
+            return targetType.GetTypeInfo().IsValueType;
+#else
+            return targetType.IsValueType;
+#endif
+        }
+
+        public static Type GetBaseType(Type targetType)
+        {
+            if (targetType == null)
+            {
+                throw new NullReferenceException("Must supply the targetType parameter");
+            }
+#if NET45            
+            return targetType.GetTypeInfo().BaseType;
+#else
+            return targetType.BaseType;
+#endif
+        }
+
+        /// <summary>
+        /// Returns the Assembly of a Type
+        /// </summary>
+        public static Assembly GetAssembly(Type targetType)
+        {
+            if (targetType == null)
+            {
+                throw new NullReferenceException("Must supply the targetType parameter");
+            }
+#if NET45            
+            return targetType.GetTypeInfo().Assembly;
+#else
+            return targetType.Assembly;
+#endif
+        }
+
+        /// <summary>
+        /// Returns true if the given type represents a non-object type that is not abstract.
+        /// </summary>
+        public static bool IsConcreteClass(Type t)
+        {
+            if (t == null)
+            {
+                throw new NullReferenceException("Must supply the t (type) parameter");
+            }
+
+            if (t == typeof(object))
+                return false;
+#if NET45            
+            var ti = t.GetTypeInfo();
+            if (ti.IsClass && !ti.IsAbstract)
+                return true;
+#else            
+            if (t.IsClass && !t.IsAbstract)
+                return true;
+#endif
+            return false;
+        }
+
+        public static MethodInfo GetMethodInfo(Type type, string methodName)
+        {
+#if NET45            
+            return type.GetTypeInfo().GetDeclaredMethod(methodName);
+#else
+            return type.GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
+#endif
+        }
+
+        public static MethodInfo GetPropertyGetMethod(PropertyInfo property)
+        {
+            if (property == null)
+            {
+                throw new NullReferenceException("Must supply the property parameter");
+            }
+
+#if NET45            
+            return property.GetMethod;
+#else
+            return property.GetGetMethod();
+#endif
+        }
+
+        public static MethodInfo GetPropertySetMethod(PropertyInfo property)
+        {
+            if (property == null)
+            {
+                throw new NullReferenceException("Must supply the property parameter");
+            }
+
+#if NET45            
+            return property.SetMethod;
+#else
+            return property.GetSetMethod();
+#endif
+        }
+
+        public static T GetCustomAttribute<T>(MemberInfo member) where T : Attribute
+        {
+            if (member == null)
+                throw new NullReferenceException("Must supply the member parameter");
+
+#if NET45            
+            return member.GetCustomAttribute(typeof(T)) as T;
+#else
+            return Attribute.GetCustomAttribute(member, typeof(T)) as T;
+#endif
+        }
+
+        /// <summary>
+        /// Returns true if the get method of the given property exist and are public.
+        /// Note that we allow a getter-only property to be serialized (and deserialized),
+        /// *if* CanDeserializeIntoExistingObject is true for the property type.
+        /// </summary>
+        public static bool PropertyIsPublic(PropertyInfo property)
+        {
+            if (property == null)
+            {
+                throw new NullReferenceException("Must supply the property parameter");
+            }
+
+            var getMethod = GetPropertyGetMethod(property);
+
+            if (getMethod == null || !getMethod.IsPublic)
+                return false;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns true if the given type can be assigned the given value
+        /// </summary>
+        public static bool IsAssignableFrom(Type type, object value)
+        {
+            if (type == null)
+                throw new ArgumentNullException("type");
+            if (value == null)
+                throw new ArgumentNullException("value");
+
+            return IsAssignableFromType(type, value.GetType());
+        }
+
+        /// <summary>
+        /// Returns true if the given type can be assigned a value with the given object type
+        /// </summary>
+        public static bool IsAssignableFromType(Type type, Type objectType)
+        {
+            if (type == null)
+                throw new ArgumentNullException("type");
+            if (objectType == null)
+                throw new ArgumentNullException("objectType");
+#if NET45
+            if (type.GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo()))
+                return true;
+#else
+            if (type.IsAssignableFrom(objectType))
+                return true;     
+#endif
+            return false;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/TimerHelper.cs b/MonoGame.Framework/Utilities/TimerHelper.cs
new file mode 100644
index 00000000000..b46084fe967
--- /dev/null
+++ b/MonoGame.Framework/Utilities/TimerHelper.cs
@@ -0,0 +1,47 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace MonoGame.Utilities
+{
+    internal static class TimerHelper
+    {
+        [DllImport("ntdll.dll", SetLastError = true)]
+        private static extern int NtQueryTimerResolution(out uint MinimumResolution, out uint MaximumResolution, out uint CurrentResolution);
+
+        private static readonly double LowestSleepThreshold;
+
+        static TimerHelper()
+        {
+            uint min, max, current;
+            NtQueryTimerResolution(out min, out max, out current);
+            LowestSleepThreshold = 1.0 + (max / 10000.0);
+        }
+
+        /// <summary>
+        /// Returns the current timer resolution in milliseconds
+        /// </summary>
+        public static double GetCurrentResolution()
+        {
+            uint min, max, current;
+            NtQueryTimerResolution(out min, out max, out current);
+            return current / 10000.0;
+        }
+
+        /// <summary>
+        /// Sleeps as long as possible without exceeding the specified period
+        /// </summary>
+        public static void SleepForNoMoreThan(double milliseconds)
+        {
+            // Assumption is that Thread.Sleep(t) will sleep for at least (t), and at most (t + timerResolution)
+            if (milliseconds < LowestSleepThreshold)
+                return;
+            var sleepTime = (int)(milliseconds - GetCurrentResolution());
+            if (sleepTime > 0)
+                Thread.Sleep(sleepTime);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Utilities/ZLibStream/ZlibStream.cs b/MonoGame.Framework/Utilities/ZLibStream/ZlibStream.cs
new file mode 100644
index 00000000000..a544c3bd578
--- /dev/null
+++ b/MonoGame.Framework/Utilities/ZLibStream/ZlibStream.cs
@@ -0,0 +1,9309 @@
+// ZlibStream.cs
+// ------------------------------------------------------------------
+//
+// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
+// All rights reserved.
+//
+// This code module is part of DotNetZip, a zipfile class library.
+//
+// ------------------------------------------------------------------
+//
+// This code is licensed under the Microsoft Public License.
+// See the file License.txt for the license details.
+// More info on: http://dotnetzip.codeplex.com
+//
+// ------------------------------------------------------------------
+//
+// last saved (in emacs):
+// Time-stamp: <2011-July-31 14:53:33>
+//
+// ------------------------------------------------------------------
+//
+// This module defines the ZlibStream class, which is similar in idea to
+// the System.IO.Compression.DeflateStream and
+// System.IO.Compression.GZipStream classes in the .NET BCL.
+//
+// ------------------------------------------------------------------
+
+// The following notice applies to jzlib:
+// -----------------------------------------------------------------------------
+
+// Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+
+// 1. Redistributions of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in
+// the documentation and/or other materials provided with the distribution.
+
+// 3. The names of the authors may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+// INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+// OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// -----------------------------------------------------------------------------
+
+// jzlib is based on zlib-1.1.3.
+
+// The following notice applies to zlib:
+
+// -----------------------------------------------------------------------------
+
+// Copyright (C) 1995-2004 Jean-loup Gailly and Mark Adler
+
+// The ZLIB software is provided 'as-is', without any express or implied
+// warranty.  In no event will the authors be held liable for any damages
+// arising from the use of this software.
+
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would be
+//    appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+//    misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+
+// Jean-loup Gailly jloup@gzip.org
+// Mark Adler madler@alumni.caltech.edu
+
+
+//------------------------------------------------------------------------------
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace MonoGame.Utilities
+{
+
+    /// <summary>
+    /// Represents a Zlib stream for compression or decompression.
+    /// </summary>
+    /// <remarks>
+    ///
+    /// <para>
+    /// The ZlibStream is a <see
+    /// href="http://en.wikipedia.org/wiki/Decorator_pattern">Decorator</see> on a <see
+    /// cref="System.IO.Stream"/>.  It adds ZLIB compression or decompression to any
+    /// stream.
+    /// </para>
+    ///
+    /// <para> Using this stream, applications can compress or decompress data via
+    /// stream <c>Read()</c> and <c>Write()</c> operations.  Either compression or
+    /// decompression can occur through either reading or writing. The compression
+    /// format used is ZLIB, which is documented in <see
+    /// href="http://www.ietf.org/rfc/rfc1950.txt">IETF RFC 1950</see>, "ZLIB Compressed
+    /// Data Format Specification version 3.3". This implementation of ZLIB always uses
+    /// DEFLATE as the compression method.  (see <see
+    /// href="http://www.ietf.org/rfc/rfc1951.txt">IETF RFC 1951</see>, "DEFLATE
+    /// Compressed Data Format Specification version 1.3.") </para>
+    ///
+    /// <para>
+    /// The ZLIB format allows for varying compression methods, window sizes, and dictionaries.
+    /// This implementation always uses the DEFLATE compression method, a preset dictionary,
+    /// and 15 window bits by default.
+    /// </para>
+    ///
+    /// <para>
+    /// This class is similar to DeflateStream, except that it adds the
+    /// RFC1950 header and trailer bytes to a compressed stream when compressing, or expects
+    /// the RFC1950 header and trailer bytes when decompressing.  It is also similar to the
+    /// <see cref="GZipStream"/>.
+    /// </para>
+    /// </remarks>
+    /// <seealso cref="GZipStream" />
+    public class ZlibStream : Stream
+    {
+        internal ZlibBaseStream _baseStream;
+        bool _disposed;
+
+        /// <summary>
+        /// Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>.
+        /// </summary>
+        /// <remarks>
+        ///
+        /// <para>
+        ///   When mode is <c>CompressionMode.Compress</c>, the <c>ZlibStream</c>
+        ///   will use the default compression level. The "captive" stream will be
+        ///   closed when the <c>ZlibStream</c> is closed.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        /// This example uses a <c>ZlibStream</c> to compress a file, and writes the
+        /// compressed data to another file.
+        /// <code>
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        /// {
+        ///     using (var raw = System.IO.File.Create(fileToCompress + ".zlib"))
+        ///     {
+        ///         using (Stream compressor = new ZlibStream(raw, CompressionMode.Compress))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n;
+        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
+        ///             {
+        ///                 compressor.Write(buffer, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        /// <code lang="VB">
+        /// Using input As Stream = File.OpenRead(fileToCompress)
+        ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".zlib")
+        ///     Using compressor As Stream = New ZlibStream(raw, CompressionMode.Compress)
+        ///         Dim buffer As Byte() = New Byte(4096) {}
+        ///         Dim n As Integer = -1
+        ///         Do While (n &lt;&gt; 0)
+        ///             If (n &gt; 0) Then
+        ///                 compressor.Write(buffer, 0, n)
+        ///             End If
+        ///             n = input.Read(buffer, 0, buffer.Length)
+        ///         Loop
+        ///     End Using
+        ///     End Using
+        /// End Using
+        /// </code>
+        /// </example>
+        ///
+        /// <param name="stream">The stream which will be read or written.</param>
+        /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
+        public ZlibStream(System.IO.Stream stream, CompressionMode mode)
+            : this(stream, mode, CompressionLevel.Default, false)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c> and
+        ///   the specified <c>CompressionLevel</c>.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   When mode is <c>CompressionMode.Decompress</c>, the level parameter is ignored.
+        ///   The "captive" stream will be closed when the <c>ZlibStream</c> is closed.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        ///   This example uses a <c>ZlibStream</c> to compress data from a file, and writes the
+        ///   compressed data to another file.
+        ///
+        /// <code>
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        /// {
+        ///     using (var raw = System.IO.File.Create(fileToCompress + ".zlib"))
+        ///     {
+        ///         using (Stream compressor = new ZlibStream(raw,
+        ///                                                   CompressionMode.Compress,
+        ///                                                   CompressionLevel.BestCompression))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n;
+        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
+        ///             {
+        ///                 compressor.Write(buffer, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        ///
+        /// <code lang="VB">
+        /// Using input As Stream = File.OpenRead(fileToCompress)
+        ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".zlib")
+        ///         Using compressor As Stream = New ZlibStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
+        ///             Dim buffer As Byte() = New Byte(4096) {}
+        ///             Dim n As Integer = -1
+        ///             Do While (n &lt;&gt; 0)
+        ///                 If (n &gt; 0) Then
+        ///                     compressor.Write(buffer, 0, n)
+        ///                 End If
+        ///                 n = input.Read(buffer, 0, buffer.Length)
+        ///             Loop
+        ///         End Using
+        ///     End Using
+        /// End Using
+        /// </code>
+        /// </example>
+        ///
+        /// <param name="stream">The stream to be read or written while deflating or inflating.</param>
+        /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
+        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
+        public ZlibStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level)
+            : this(stream, mode, level, false)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>, and
+        ///   explicitly specify whether the captive stream should be left open after
+        ///   Deflation or Inflation.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   When mode is <c>CompressionMode.Compress</c>, the <c>ZlibStream</c> will use
+        ///   the default compression level.
+        /// </para>
+        ///
+        /// <para>
+        ///   This constructor allows the application to request that the captive stream
+        ///   remain open after the deflation or inflation occurs.  By default, after
+        ///   <c>Close()</c> is called on the stream, the captive stream is also
+        ///   closed. In some cases this is not desired, for example if the stream is a
+        ///   <see cref="System.IO.MemoryStream"/> that will be re-read after
+        ///   compression.  Specify true for the <paramref name="leaveOpen"/> parameter to leave the stream
+        ///   open.
+        /// </para>
+        ///
+        /// <para>
+        /// See the other overloads of this constructor for example code.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <param name="stream">The stream which will be read or written. This is called the
+        /// "captive" stream in other places in this documentation.</param>
+        /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
+        /// <param name="leaveOpen">true if the application would like the stream to remain
+        /// open after inflation/deflation.</param>
+        public ZlibStream(System.IO.Stream stream, CompressionMode mode, bool leaveOpen)
+            : this(stream, mode, CompressionLevel.Default, leaveOpen)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>ZlibStream</c> using the specified <c>CompressionMode</c>
+        ///   and the specified <c>CompressionLevel</c>, and explicitly specify
+        ///   whether the stream should be left open after Deflation or Inflation.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   This constructor allows the application to request that the captive
+        ///   stream remain open after the deflation or inflation occurs.  By
+        ///   default, after <c>Close()</c> is called on the stream, the captive
+        ///   stream is also closed. In some cases this is not desired, for example
+        ///   if the stream is a <see cref="System.IO.MemoryStream"/> that will be
+        ///   re-read after compression.  Specify true for the <paramref
+        ///   name="leaveOpen"/> parameter to leave the stream open.
+        /// </para>
+        ///
+        /// <para>
+        ///   When mode is <c>CompressionMode.Decompress</c>, the level parameter is
+        ///   ignored.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        ///
+        /// This example shows how to use a ZlibStream to compress the data from a file,
+        /// and store the result into another file. The filestream remains open to allow
+        /// additional data to be written to it.
+        ///
+        /// <code>
+        /// using (var output = System.IO.File.Create(fileToCompress + ".zlib"))
+        /// {
+        ///     using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        ///     {
+        ///         using (Stream compressor = new ZlibStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, true))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n;
+        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
+        ///             {
+        ///                 compressor.Write(buffer, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        ///     // can write additional data to the output stream here
+        /// }
+        /// </code>
+        /// <code lang="VB">
+        /// Using output As FileStream = File.Create(fileToCompress &amp; ".zlib")
+        ///     Using input As Stream = File.OpenRead(fileToCompress)
+        ///         Using compressor As Stream = New ZlibStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, True)
+        ///             Dim buffer As Byte() = New Byte(4096) {}
+        ///             Dim n As Integer = -1
+        ///             Do While (n &lt;&gt; 0)
+        ///                 If (n &gt; 0) Then
+        ///                     compressor.Write(buffer, 0, n)
+        ///                 End If
+        ///                 n = input.Read(buffer, 0, buffer.Length)
+        ///             Loop
+        ///         End Using
+        ///     End Using
+        ///     ' can write additional data to the output stream here.
+        /// End Using
+        /// </code>
+        /// </example>
+        ///
+        /// <param name="stream">The stream which will be read or written.</param>
+        ///
+        /// <param name="mode">Indicates whether the ZlibStream will compress or decompress.</param>
+        ///
+        /// <param name="leaveOpen">
+        /// true if the application would like the stream to remain open after
+        /// inflation/deflation.
+        /// </param>
+        ///
+        /// <param name="level">
+        /// A tuning knob to trade speed for effectiveness. This parameter is
+        /// effective only when mode is <c>CompressionMode.Compress</c>.
+        /// </param>
+        public ZlibStream(System.IO.Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
+        {
+            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.ZLIB, leaveOpen);
+        }
+
+        #region Zlib properties
+
+        /// <summary>
+        /// This property sets the flush behavior on the stream.
+        /// Sorry, though, not sure exactly how to describe all the various settings.
+        /// </summary>
+        virtual public FlushType FlushMode
+        {
+            get { return (this._baseStream._flushMode); }
+            set
+            {
+                if (_disposed) throw new ObjectDisposedException("ZlibStream");
+                this._baseStream._flushMode = value;
+            }
+        }
+
+        /// <summary>
+        ///   The size of the working buffer for the compression codec.
+        /// </summary>
+        ///
+        /// <remarks>
+        /// <para>
+        ///   The working buffer is used for all stream operations.  The default size is
+        ///   1024 bytes. The minimum size is 128 bytes. You may get better performance
+        ///   with a larger buffer.  Then again, you might not.  You would have to test
+        ///   it.
+        /// </para>
+        ///
+        /// <para>
+        ///   Set this before the first call to <c>Read()</c> or <c>Write()</c> on the
+        ///   stream. If you try to set it afterwards, it will throw.
+        /// </para>
+        /// </remarks>
+        public int BufferSize
+        {
+            get
+            {
+                return this._baseStream._bufferSize;
+            }
+            set
+            {
+                if (_disposed) throw new ObjectDisposedException("ZlibStream");
+                if (this._baseStream._workingBuffer != null)
+                    throw new ZlibException("The working buffer is already set.");
+                if (value < ZlibConstants.WorkingBufferSizeMin)
+                    throw new ZlibException(String.Format("Don't be silly. {0} bytes?? Use a bigger buffer, at least {1}.", value, ZlibConstants.WorkingBufferSizeMin));
+                this._baseStream._bufferSize = value;
+            }
+        }
+
+        /// <summary> Returns the total number of bytes input so far.</summary>
+        virtual public long TotalIn
+        {
+            get { return this._baseStream._z.TotalBytesIn; }
+        }
+
+        /// <summary> Returns the total number of bytes output so far.</summary>
+        virtual public long TotalOut
+        {
+            get { return this._baseStream._z.TotalBytesOut; }
+        }
+
+        #endregion
+
+        #region System.IO.Stream methods
+
+        /// <summary>
+        ///   Dispose the stream.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     This may or may not result in a <c>Close()</c> call on the captive
+        ///     stream.  See the constructors that have a <c>leaveOpen</c> parameter
+        ///     for more information.
+        ///   </para>
+        ///   <para>
+        ///     This method may be invoked in two distinct scenarios.  If disposing
+        ///     == true, the method has been called directly or indirectly by a
+        ///     user's code, for example via the public Dispose() method. In this
+        ///     case, both managed and unmanaged resources can be referenced and
+        ///     disposed.  If disposing == false, the method has been called by the
+        ///     runtime from inside the object finalizer and this method should not
+        ///     reference other objects; in that case only unmanaged resources must
+        ///     be referenced or disposed.
+        ///   </para>
+        /// </remarks>
+        /// <param name="disposing">
+        ///   indicates whether the Dispose method was invoked by user code.
+        /// </param>
+        protected override void Dispose(bool disposing)
+        {
+            try
+            {
+                if (!_disposed)
+                {
+                    if (disposing && (this._baseStream != null))
+                        this._baseStream.Dispose();
+                    _disposed = true;
+                }
+            }
+            finally
+            {
+                base.Dispose(disposing);
+            }
+        }
+
+
+        /// <summary>
+        /// Indicates whether the stream can be read.
+        /// </summary>
+        /// <remarks>
+        /// The return value depends on whether the captive stream supports reading.
+        /// </remarks>
+        public override bool CanRead
+        {
+            get
+            {
+                if (_disposed) throw new ObjectDisposedException("ZlibStream");
+                return _baseStream._stream.CanRead;
+            }
+        }
+
+        /// <summary>
+        /// Indicates whether the stream supports Seek operations.
+        /// </summary>
+        /// <remarks>
+        /// Always returns false.
+        /// </remarks>
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// Indicates whether the stream can be written.
+        /// </summary>
+        /// <remarks>
+        /// The return value depends on whether the captive stream supports writing.
+        /// </remarks>
+        public override bool CanWrite
+        {
+            get
+            {
+                if (_disposed) throw new ObjectDisposedException("ZlibStream");
+                return _baseStream._stream.CanWrite;
+            }
+        }
+
+        /// <summary>
+        /// Flush the stream.
+        /// </summary>
+        public override void Flush()
+        {
+            if (_disposed) throw new ObjectDisposedException("ZlibStream");
+            _baseStream.Flush();
+        }
+
+        /// <summary>
+        /// Reading this property always throws a <see cref="NotSupportedException"/>.
+        /// </summary>
+        public override long Length
+        {
+            get { throw new NotSupportedException(); }
+        }
+
+        /// <summary>
+        ///   The position of the stream pointer.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Setting this property always throws a <see
+        ///   cref="NotSupportedException"/>. Reading will return the total bytes
+        ///   written out, if used in writing, or the total bytes read in, if used in
+        ///   reading.  The count may refer to compressed bytes or uncompressed bytes,
+        ///   depending on how you've used the stream.
+        /// </remarks>
+        public override long Position
+        {
+            get
+            {
+                if (this._baseStream._streamMode == ZlibBaseStream.StreamMode.Writer)
+                    return this._baseStream._z.TotalBytesOut;
+                if (this._baseStream._streamMode == ZlibBaseStream.StreamMode.Reader)
+                    return this._baseStream._z.TotalBytesIn;
+                return 0;
+            }
+
+            set { throw new NotSupportedException(); }
+        }
+
+        /// <summary>
+        /// Read data from the stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   If you wish to use the <c>ZlibStream</c> to compress data while reading,
+        ///   you can create a <c>ZlibStream</c> with <c>CompressionMode.Compress</c>,
+        ///   providing an uncompressed data stream.  Then call <c>Read()</c> on that
+        ///   <c>ZlibStream</c>, and the data read will be compressed.  If you wish to
+        ///   use the <c>ZlibStream</c> to decompress data while reading, you can create
+        ///   a <c>ZlibStream</c> with <c>CompressionMode.Decompress</c>, providing a
+        ///   readable compressed data stream.  Then call <c>Read()</c> on that
+        ///   <c>ZlibStream</c>, and the data will be decompressed as it is read.
+        /// </para>
+        ///
+        /// <para>
+        ///   A <c>ZlibStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but
+        ///   not both.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <param name="buffer">
+        /// The buffer into which the read data should be placed.</param>
+        ///
+        /// <param name="offset">
+        /// the offset within that data array to put the first byte read.</param>
+        ///
+        /// <param name="count">the number of bytes to read.</param>
+        ///
+        /// <returns>the number of bytes read</returns>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (_disposed) throw new ObjectDisposedException("ZlibStream");
+            return _baseStream.Read(buffer, offset, count);
+        }
+
+        /// <summary>
+        /// Calling this method always throws a <see cref="NotSupportedException"/>.
+        /// </summary>
+        /// <param name="offset">
+        ///   The offset to seek to....
+        ///   IF THIS METHOD ACTUALLY DID ANYTHING.
+        /// </param>
+        /// <param name="origin">
+        ///   The reference specifying how to apply the offset....  IF
+        ///   THIS METHOD ACTUALLY DID ANYTHING.
+        /// </param>
+        ///
+        /// <returns>nothing. This method always throws.</returns>
+        public override long Seek(long offset, System.IO.SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Calling this method always throws a <see cref="NotSupportedException"/>.
+        /// </summary>
+        /// <param name="value">
+        ///   The new value for the stream length....  IF
+        ///   THIS METHOD ACTUALLY DID ANYTHING.
+        /// </param>
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Write data to the stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   If you wish to use the <c>ZlibStream</c> to compress data while writing,
+        ///   you can create a <c>ZlibStream</c> with <c>CompressionMode.Compress</c>,
+        ///   and a writable output stream.  Then call <c>Write()</c> on that
+        ///   <c>ZlibStream</c>, providing uncompressed data as input.  The data sent to
+        ///   the output stream will be the compressed form of the data written.  If you
+        ///   wish to use the <c>ZlibStream</c> to decompress data while writing, you
+        ///   can create a <c>ZlibStream</c> with <c>CompressionMode.Decompress</c>, and a
+        ///   writable output stream.  Then call <c>Write()</c> on that stream,
+        ///   providing previously compressed data. The data sent to the output stream
+        ///   will be the decompressed form of the data written.
+        /// </para>
+        ///
+        /// <para>
+        ///   A <c>ZlibStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but not both.
+        /// </para>
+        /// </remarks>
+        /// <param name="buffer">The buffer holding data to write to the stream.</param>
+        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
+        /// <param name="count">the number of bytes to write.</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (_disposed) throw new ObjectDisposedException("ZlibStream");
+            _baseStream.Write(buffer, offset, count);
+        }
+        #endregion
+
+
+        /// <summary>
+        ///   Compress a string into a byte array using ZLIB.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Uncompress it with <see cref="ZlibStream.UncompressString(byte[])"/>.
+        /// </remarks>
+        ///
+        /// <seealso cref="ZlibStream.UncompressString(byte[])"/>
+        /// <seealso cref="ZlibStream.CompressBuffer(byte[])"/>
+        /// <seealso cref="GZipStream.CompressString(string)"/>
+        ///
+        /// <param name="s">
+        ///   A string to compress.  The string will first be encoded
+        ///   using UTF8, then compressed.
+        /// </param>
+        ///
+        /// <returns>The string in compressed form</returns>
+        public static byte[] CompressString(String s)
+        {
+            using (var ms = new MemoryStream())
+            {
+                Stream compressor =
+                    new ZlibStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression);
+                ZlibBaseStream.CompressString(s, compressor);
+                return ms.ToArray();
+            }
+        }
+
+
+        /// <summary>
+        ///   Compress a byte array into a new byte array using ZLIB.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Uncompress it with <see cref="ZlibStream.UncompressBuffer(byte[])"/>.
+        /// </remarks>
+        ///
+        /// <seealso cref="ZlibStream.CompressString(string)"/>
+        /// <seealso cref="ZlibStream.UncompressBuffer(byte[])"/>
+        ///
+        /// <param name="b">
+        /// A buffer to compress.
+        /// </param>
+        ///
+        /// <returns>The data in compressed form</returns>
+        public static byte[] CompressBuffer(byte[] b)
+        {
+            using (var ms = new MemoryStream())
+            {
+                Stream compressor =
+                    new ZlibStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression);
+
+                ZlibBaseStream.CompressBuffer(b, compressor);
+                return ms.ToArray();
+            }
+        }
+
+
+        /// <summary>
+        ///   Uncompress a ZLIB-compressed byte array into a single string.
+        /// </summary>
+        ///
+        /// <seealso cref="ZlibStream.CompressString(String)"/>
+        /// <seealso cref="ZlibStream.UncompressBuffer(byte[])"/>
+        ///
+        /// <param name="compressed">
+        ///   A buffer containing ZLIB-compressed data.
+        /// </param>
+        ///
+        /// <returns>The uncompressed string</returns>
+        public static String UncompressString(byte[] compressed)
+        {
+            using (var input = new MemoryStream(compressed))
+            {
+                Stream decompressor =
+                    new ZlibStream(input, CompressionMode.Decompress);
+
+                return ZlibBaseStream.UncompressString(compressed, decompressor);
+            }
+        }
+
+
+        /// <summary>
+        ///   Uncompress a ZLIB-compressed byte array into a byte array.
+        /// </summary>
+        ///
+        /// <seealso cref="ZlibStream.CompressBuffer(byte[])"/>
+        /// <seealso cref="ZlibStream.UncompressString(byte[])"/>
+        ///
+        /// <param name="compressed">
+        ///   A buffer containing ZLIB-compressed data.
+        /// </param>
+        ///
+        /// <returns>The data in uncompressed form</returns>
+        public static byte[] UncompressBuffer(byte[] compressed)
+        {
+            using (var input = new MemoryStream(compressed))
+            {
+                Stream decompressor =
+                    new ZlibStream(input, CompressionMode.Decompress);
+
+                return ZlibBaseStream.UncompressBuffer(compressed, decompressor);
+            }
+        }
+
+    }
+
+    /// <summary>
+    /// A bunch of constants used in the Zlib interface.
+    /// </summary>
+    internal static class ZlibConstants
+    {
+        /// <summary>
+        /// The maximum number of window bits for the Deflate algorithm.
+        /// </summary>
+        internal const int WindowBitsMax = 15; // 32K LZ77 window
+
+        /// <summary>
+        /// The default number of window bits for the Deflate algorithm.
+        /// </summary>
+        internal const int WindowBitsDefault = WindowBitsMax;
+
+        /// <summary>
+        /// indicates everything is A-OK
+        /// </summary>
+        internal const int Z_OK = 0;
+
+        /// <summary>
+        /// Indicates that the last operation reached the end of the stream.
+        /// </summary>
+        internal const int Z_STREAM_END = 1;
+
+        /// <summary>
+        /// The operation ended in need of a dictionary. 
+        /// </summary>
+        internal const int Z_NEED_DICT = 2;
+
+        /// <summary>
+        /// There was an error with the stream - not enough data, not open and readable, etc.
+        /// </summary>
+        internal const int Z_STREAM_ERROR = -2;
+
+        /// <summary>
+        /// There was an error with the data - not enough data, bad data, etc.
+        /// </summary>
+        internal const int Z_DATA_ERROR = -3;
+
+        /// <summary>
+        /// There was an error with the working buffer.
+        /// </summary>
+        internal const int Z_BUF_ERROR = -5;
+
+        /// <summary>
+        /// The size of the working buffer used in the ZlibCodec class. Defaults to 8192 bytes.
+        /// </summary>
+#if NETCF        
+        internal const int WorkingBufferSizeDefault = 8192;
+#else
+        internal const int WorkingBufferSizeDefault = 16384;
+#endif
+        /// <summary>
+        /// The minimum size of the working buffer used in the ZlibCodec class.  Currently it is 128 bytes.
+        /// </summary>
+        internal const int WorkingBufferSizeMin = 1024;
+    }
+
+    /// <summary>
+    /// Encoder and Decoder for ZLIB and DEFLATE (IETF RFC1950 and RFC1951).
+    /// </summary>
+    ///
+    /// <remarks>
+    /// This class compresses and decompresses data according to the Deflate algorithm
+    /// and optionally, the ZLIB format, as documented in <see
+    /// href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950 - ZLIB</see> and <see
+    /// href="http://www.ietf.org/rfc/rfc1951.txt">RFC 1951 - DEFLATE</see>.
+    /// </remarks>
+
+    sealed internal class ZlibCodec
+    {
+        /// <summary>
+        /// The buffer from which data is taken.
+        /// </summary>
+        internal byte[] InputBuffer;
+
+        /// <summary>
+        /// An index into the InputBuffer array, indicating where to start reading. 
+        /// </summary>
+        internal int NextIn;
+
+        /// <summary>
+        /// The number of bytes available in the InputBuffer, starting at NextIn. 
+        /// </summary>
+        /// <remarks>
+        /// Generally you should set this to InputBuffer.Length before the first Inflate() or Deflate() call. 
+        /// The class will update this number as calls to Inflate/Deflate are made.
+        /// </remarks>
+        internal int AvailableBytesIn;
+
+        /// <summary>
+        /// Total number of bytes read so far, through all calls to Inflate()/Deflate().
+        /// </summary>
+        internal long TotalBytesIn;
+
+        /// <summary>
+        /// Buffer to store output data.
+        /// </summary>
+        internal byte[] OutputBuffer;
+
+        /// <summary>
+        /// An index into the OutputBuffer array, indicating where to start writing. 
+        /// </summary>
+        internal int NextOut;
+
+        /// <summary>
+        /// The number of bytes available in the OutputBuffer, starting at NextOut. 
+        /// </summary>
+        /// <remarks>
+        /// Generally you should set this to OutputBuffer.Length before the first Inflate() or Deflate() call. 
+        /// The class will update this number as calls to Inflate/Deflate are made.
+        /// </remarks>
+        internal int AvailableBytesOut;
+
+        /// <summary>
+        /// Total number of bytes written to the output so far, through all calls to Inflate()/Deflate().
+        /// </summary>
+        internal long TotalBytesOut;
+
+        /// <summary>
+        /// used for diagnostics, when something goes wrong!
+        /// </summary>
+        internal System.String Message;
+
+        internal DeflateManager dstate;
+        internal InflateManager istate;
+
+        internal uint _Adler32;
+
+        /// <summary>
+        /// The compression level to use in this codec.  Useful only in compression mode.
+        /// </summary>
+        internal CompressionLevel CompressLevel = CompressionLevel.Default;
+
+        /// <summary>
+        /// The number of Window Bits to use.  
+        /// </summary>
+        /// <remarks>
+        /// This gauges the size of the sliding window, and hence the 
+        /// compression effectiveness as well as memory consumption. It's best to just leave this 
+        /// setting alone if you don't know what it is.  The maximum value is 15 bits, which implies
+        /// a 32k window.  
+        /// </remarks>
+        internal int WindowBits = ZlibConstants.WindowBitsDefault;
+
+        /// <summary>
+        /// The compression strategy to use.
+        /// </summary>
+        /// <remarks>
+        /// This is only effective in compression.  The theory offered by ZLIB is that different
+        /// strategies could potentially produce significant differences in compression behavior
+        /// for different data sets.  Unfortunately I don't have any good recommendations for how
+        /// to set it differently.  When I tested changing the strategy I got minimally different
+        /// compression performance. It's best to leave this property alone if you don't have a
+        /// good feel for it.  Or, you may want to produce a test harness that runs through the
+        /// different strategy options and evaluates them on different file types. If you do that,
+        /// let me know your results.
+        /// </remarks>
+        internal CompressionStrategy Strategy = CompressionStrategy.Default;
+
+
+        /// <summary>
+        /// The Adler32 checksum on the data transferred through the codec so far. You probably don't need to look at this.
+        /// </summary>
+        internal int Adler32 { get { return (int)_Adler32; } }
+
+
+        /// <summary>
+        /// Create a ZlibCodec.
+        /// </summary>
+        /// <remarks>
+        /// If you use this default constructor, you will later have to explicitly call 
+        /// InitializeInflate() or InitializeDeflate() before using the ZlibCodec to compress 
+        /// or decompress. 
+        /// </remarks>
+        internal ZlibCodec() { }
+
+        /// <summary>
+        /// Create a ZlibCodec that either compresses or decompresses.
+        /// </summary>
+        /// <param name="mode">
+        /// Indicates whether the codec should compress (deflate) or decompress (inflate).
+        /// </param>
+        internal ZlibCodec(CompressionMode mode)
+        {
+            if (mode == CompressionMode.Compress)
+            {
+                int rc = InitializeDeflate();
+                if (rc != ZlibConstants.Z_OK) throw new ZlibException("Cannot initialize for deflate.");
+            }
+            else if (mode == CompressionMode.Decompress)
+            {
+                int rc = InitializeInflate();
+                if (rc != ZlibConstants.Z_OK) throw new ZlibException("Cannot initialize for inflate.");
+            }
+            else throw new ZlibException("Invalid ZlibStreamFlavor.");
+        }
+
+        /// <summary>
+        /// Initialize the inflation state. 
+        /// </summary>
+        /// <remarks>
+        /// It is not necessary to call this before using the ZlibCodec to inflate data; 
+        /// It is implicitly called when you call the constructor.
+        /// </remarks>
+        /// <returns>Z_OK if everything goes well.</returns>
+        internal int InitializeInflate()
+        {
+            return InitializeInflate(this.WindowBits);
+        }
+
+        /// <summary>
+        /// Initialize the inflation state with an explicit flag to
+        /// govern the handling of RFC1950 header bytes.
+        /// </summary>
+        ///
+        /// <remarks>
+        /// By default, the ZLIB header defined in <see
+        /// href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950</see> is expected.  If
+        /// you want to read a zlib stream you should specify true for
+        /// expectRfc1950Header.  If you have a deflate stream, you will want to specify
+        /// false. It is only necessary to invoke this initializer explicitly if you
+        /// want to specify false.
+        /// </remarks>
+        ///
+        /// <param name="expectRfc1950Header">whether to expect an RFC1950 header byte
+        /// pair when reading the stream of data to be inflated.</param>
+        ///
+        /// <returns>Z_OK if everything goes well.</returns>
+        internal int InitializeInflate(bool expectRfc1950Header)
+        {
+            return InitializeInflate(this.WindowBits, expectRfc1950Header);
+        }
+
+        /// <summary>
+        /// Initialize the ZlibCodec for inflation, with the specified number of window bits. 
+        /// </summary>
+        /// <param name="windowBits">The number of window bits to use. If you need to ask what that is, 
+        /// then you shouldn't be calling this initializer.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        internal int InitializeInflate(int windowBits)
+        {
+            this.WindowBits = windowBits;
+            return InitializeInflate(windowBits, true);
+        }
+
+        /// <summary>
+        /// Initialize the inflation state with an explicit flag to govern the handling of
+        /// RFC1950 header bytes. 
+        /// </summary>
+        ///
+        /// <remarks>
+        /// If you want to read a zlib stream you should specify true for
+        /// expectRfc1950Header. In this case, the library will expect to find a ZLIB
+        /// header, as defined in <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC
+        /// 1950</see>, in the compressed stream.  If you will be reading a DEFLATE or
+        /// GZIP stream, which does not have such a header, you will want to specify
+        /// false.
+        /// </remarks>
+        ///
+        /// <param name="expectRfc1950Header">whether to expect an RFC1950 header byte pair when reading 
+        /// the stream of data to be inflated.</param>
+        /// <param name="windowBits">The number of window bits to use. If you need to ask what that is, 
+        /// then you shouldn't be calling this initializer.</param>
+        /// <returns>Z_OK if everything goes well.</returns>
+        internal int InitializeInflate(int windowBits, bool expectRfc1950Header)
+        {
+            this.WindowBits = windowBits;
+            if (dstate != null) throw new ZlibException("You may not call InitializeInflate() after calling InitializeDeflate().");
+            istate = new InflateManager(expectRfc1950Header);
+            return istate.Initialize(this, windowBits);
+        }
+
+        /// <summary>
+        /// Inflate the data in the InputBuffer, placing the result in the OutputBuffer.
+        /// </summary>
+        /// <remarks>
+        /// You must have set InputBuffer and OutputBuffer, NextIn and NextOut, and AvailableBytesIn and 
+        /// AvailableBytesOut  before calling this method.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// private void InflateBuffer()
+        /// {
+        ///     int bufferSize = 1024;
+        ///     byte[] buffer = new byte[bufferSize];
+        ///     ZlibCodec decompressor = new ZlibCodec();
+        /// 
+        ///     Console.WriteLine("\n============================================");
+        ///     Console.WriteLine("Size of Buffer to Inflate: {0} bytes.", CompressedBytes.Length);
+        ///     MemoryStream ms = new MemoryStream(DecompressedBytes);
+        /// 
+        ///     int rc = decompressor.InitializeInflate();
+        /// 
+        ///     decompressor.InputBuffer = CompressedBytes;
+        ///     decompressor.NextIn = 0;
+        ///     decompressor.AvailableBytesIn = CompressedBytes.Length;
+        /// 
+        ///     decompressor.OutputBuffer = buffer;
+        /// 
+        ///     // pass 1: inflate 
+        ///     do
+        ///     {
+        ///         decompressor.NextOut = 0;
+        ///         decompressor.AvailableBytesOut = buffer.Length;
+        ///         rc = decompressor.Inflate(FlushType.None);
+        /// 
+        ///         if (rc != ZlibConstants.Z_OK &amp;&amp; rc != ZlibConstants.Z_STREAM_END)
+        ///             throw new Exception("inflating: " + decompressor.Message);
+        /// 
+        ///         ms.Write(decompressor.OutputBuffer, 0, buffer.Length - decompressor.AvailableBytesOut);
+        ///     }
+        ///     while (decompressor.AvailableBytesIn &gt; 0 || decompressor.AvailableBytesOut == 0);
+        /// 
+        ///     // pass 2: finish and flush
+        ///     do
+        ///     {
+        ///         decompressor.NextOut = 0;
+        ///         decompressor.AvailableBytesOut = buffer.Length;
+        ///         rc = decompressor.Inflate(FlushType.Finish);
+        /// 
+        ///         if (rc != ZlibConstants.Z_STREAM_END &amp;&amp; rc != ZlibConstants.Z_OK)
+        ///             throw new Exception("inflating: " + decompressor.Message);
+        /// 
+        ///         if (buffer.Length - decompressor.AvailableBytesOut &gt; 0)
+        ///             ms.Write(buffer, 0, buffer.Length - decompressor.AvailableBytesOut);
+        ///     }
+        ///     while (decompressor.AvailableBytesIn &gt; 0 || decompressor.AvailableBytesOut == 0);
+        /// 
+        ///     decompressor.EndInflate();
+        /// }
+        ///
+        /// </code>
+        /// </example>
+        /// <param name="flush">The flush to use when inflating.</param>
+        /// <returns>Z_OK if everything goes well.</returns>
+        internal int Inflate(FlushType flush)
+        {
+            if (istate == null)
+                throw new ZlibException("No Inflate State!");
+            return istate.Inflate(flush);
+        }
+
+
+        /// <summary>
+        /// Ends an inflation session. 
+        /// </summary>
+        /// <remarks>
+        /// Call this after successively calling Inflate().  This will cause all buffers to be flushed. 
+        /// After calling this you cannot call Inflate() without a intervening call to one of the
+        /// InitializeInflate() overloads.
+        /// </remarks>
+        /// <returns>Z_OK if everything goes well.</returns>
+        internal int EndInflate()
+        {
+            if (istate == null)
+                throw new ZlibException("No Inflate State!");
+            int ret = istate.End();
+            istate = null;
+            return ret;
+        }
+
+        /// <summary>
+        /// I don't know what this does!
+        /// </summary>
+        /// <returns>Z_OK if everything goes well.</returns>
+        internal int SyncInflate()
+        {
+            if (istate == null)
+                throw new ZlibException("No Inflate State!");
+            return istate.Sync();
+        }
+
+        /// <summary>
+        /// Initialize the ZlibCodec for deflation operation.
+        /// </summary>
+        /// <remarks>
+        /// The codec will use the MAX window bits and the default level of compression.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        ///  int bufferSize = 40000;
+        ///  byte[] CompressedBytes = new byte[bufferSize];
+        ///  byte[] DecompressedBytes = new byte[bufferSize];
+        ///  
+        ///  ZlibCodec compressor = new ZlibCodec();
+        ///  
+        ///  compressor.InitializeDeflate(CompressionLevel.Default);
+        ///  
+        ///  compressor.InputBuffer = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);
+        ///  compressor.NextIn = 0;
+        ///  compressor.AvailableBytesIn = compressor.InputBuffer.Length;
+        ///  
+        ///  compressor.OutputBuffer = CompressedBytes;
+        ///  compressor.NextOut = 0;
+        ///  compressor.AvailableBytesOut = CompressedBytes.Length;
+        ///  
+        ///  while (compressor.TotalBytesIn != TextToCompress.Length &amp;&amp; compressor.TotalBytesOut &lt; bufferSize)
+        ///  {
+        ///    compressor.Deflate(FlushType.None);
+        ///  }
+        ///  
+        ///  while (true)
+        ///  {
+        ///    int rc= compressor.Deflate(FlushType.Finish);
+        ///    if (rc == ZlibConstants.Z_STREAM_END) break;
+        ///  }
+        ///  
+        ///  compressor.EndDeflate();
+        ///   
+        /// </code>
+        /// </example>
+        /// <returns>Z_OK if all goes well. You generally don't need to check the return code.</returns>
+        internal int InitializeDeflate()
+        {
+            return _InternalInitializeDeflate(true);
+        }
+
+        /// <summary>
+        /// Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel.
+        /// </summary>
+        /// <remarks>
+        /// The codec will use the maximum window bits (15) and the specified
+        /// CompressionLevel.  It will emit a ZLIB stream as it compresses.
+        /// </remarks>
+        /// <param name="level">The compression level for the codec.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        internal int InitializeDeflate(CompressionLevel level)
+        {
+            this.CompressLevel = level;
+            return _InternalInitializeDeflate(true);
+        }
+
+
+        /// <summary>
+        /// Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel, 
+        /// and the explicit flag governing whether to emit an RFC1950 header byte pair.
+        /// </summary>
+        /// <remarks>
+        /// The codec will use the maximum window bits (15) and the specified CompressionLevel.
+        /// If you want to generate a zlib stream, you should specify true for
+        /// wantRfc1950Header. In this case, the library will emit a ZLIB
+        /// header, as defined in <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC
+        /// 1950</see>, in the compressed stream.  
+        /// </remarks>
+        /// <param name="level">The compression level for the codec.</param>
+        /// <param name="wantRfc1950Header">whether to emit an initial RFC1950 byte pair in the compressed stream.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        internal int InitializeDeflate(CompressionLevel level, bool wantRfc1950Header)
+        {
+            this.CompressLevel = level;
+            return _InternalInitializeDeflate(wantRfc1950Header);
+        }
+
+
+        /// <summary>
+        /// Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel, 
+        /// and the specified number of window bits. 
+        /// </summary>
+        /// <remarks>
+        /// The codec will use the specified number of window bits and the specified CompressionLevel.
+        /// </remarks>
+        /// <param name="level">The compression level for the codec.</param>
+        /// <param name="bits">the number of window bits to use.  If you don't know what this means, don't use this method.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        internal int InitializeDeflate(CompressionLevel level, int bits)
+        {
+            this.CompressLevel = level;
+            this.WindowBits = bits;
+            return _InternalInitializeDeflate(true);
+        }
+
+        /// <summary>
+        /// Initialize the ZlibCodec for deflation operation, using the specified
+        /// CompressionLevel, the specified number of window bits, and the explicit flag
+        /// governing whether to emit an RFC1950 header byte pair.
+        /// </summary>
+        ///
+        /// <param name="level">The compression level for the codec.</param>
+        /// <param name="wantRfc1950Header">whether to emit an initial RFC1950 byte pair in the compressed stream.</param>
+        /// <param name="bits">the number of window bits to use.  If you don't know what this means, don't use this method.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        internal int InitializeDeflate(CompressionLevel level, int bits, bool wantRfc1950Header)
+        {
+            this.CompressLevel = level;
+            this.WindowBits = bits;
+            return _InternalInitializeDeflate(wantRfc1950Header);
+        }
+
+        private int _InternalInitializeDeflate(bool wantRfc1950Header)
+        {
+            if (istate != null) throw new ZlibException("You may not call InitializeDeflate() after calling InitializeInflate().");
+            dstate = new DeflateManager();
+            dstate.WantRfc1950HeaderBytes = wantRfc1950Header;
+
+            return dstate.Initialize(this, this.CompressLevel, this.WindowBits, this.Strategy);
+        }
+
+        /// <summary>
+        /// Deflate one batch of data.
+        /// </summary>
+        /// <remarks>
+        /// You must have set InputBuffer and OutputBuffer before calling this method.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// private void DeflateBuffer(CompressionLevel level)
+        /// {
+        ///     int bufferSize = 1024;
+        ///     byte[] buffer = new byte[bufferSize];
+        ///     ZlibCodec compressor = new ZlibCodec();
+        /// 
+        ///     Console.WriteLine("\n============================================");
+        ///     Console.WriteLine("Size of Buffer to Deflate: {0} bytes.", UncompressedBytes.Length);
+        ///     MemoryStream ms = new MemoryStream();
+        /// 
+        ///     int rc = compressor.InitializeDeflate(level);
+        /// 
+        ///     compressor.InputBuffer = UncompressedBytes;
+        ///     compressor.NextIn = 0;
+        ///     compressor.AvailableBytesIn = UncompressedBytes.Length;
+        /// 
+        ///     compressor.OutputBuffer = buffer;
+        /// 
+        ///     // pass 1: deflate 
+        ///     do
+        ///     {
+        ///         compressor.NextOut = 0;
+        ///         compressor.AvailableBytesOut = buffer.Length;
+        ///         rc = compressor.Deflate(FlushType.None);
+        /// 
+        ///         if (rc != ZlibConstants.Z_OK &amp;&amp; rc != ZlibConstants.Z_STREAM_END)
+        ///             throw new Exception("deflating: " + compressor.Message);
+        /// 
+        ///         ms.Write(compressor.OutputBuffer, 0, buffer.Length - compressor.AvailableBytesOut);
+        ///     }
+        ///     while (compressor.AvailableBytesIn &gt; 0 || compressor.AvailableBytesOut == 0);
+        /// 
+        ///     // pass 2: finish and flush
+        ///     do
+        ///     {
+        ///         compressor.NextOut = 0;
+        ///         compressor.AvailableBytesOut = buffer.Length;
+        ///         rc = compressor.Deflate(FlushType.Finish);
+        /// 
+        ///         if (rc != ZlibConstants.Z_STREAM_END &amp;&amp; rc != ZlibConstants.Z_OK)
+        ///             throw new Exception("deflating: " + compressor.Message);
+        /// 
+        ///         if (buffer.Length - compressor.AvailableBytesOut &gt; 0)
+        ///             ms.Write(buffer, 0, buffer.Length - compressor.AvailableBytesOut);
+        ///     }
+        ///     while (compressor.AvailableBytesIn &gt; 0 || compressor.AvailableBytesOut == 0);
+        /// 
+        ///     compressor.EndDeflate();
+        /// 
+        ///     ms.Seek(0, SeekOrigin.Begin);
+        ///     CompressedBytes = new byte[compressor.TotalBytesOut];
+        ///     ms.Read(CompressedBytes, 0, CompressedBytes.Length);
+        /// }
+        /// </code>
+        /// </example>
+        /// <param name="flush">whether to flush all data as you deflate. Generally you will want to 
+        /// use Z_NO_FLUSH here, in a series of calls to Deflate(), and then call EndDeflate() to 
+        /// flush everything. 
+        /// </param>
+        /// <returns>Z_OK if all goes well.</returns>
+        internal int Deflate(FlushType flush)
+        {
+            if (dstate == null)
+                throw new ZlibException("No Deflate State!");
+            return dstate.Deflate(flush);
+        }
+
+        /// <summary>
+        /// End a deflation session.
+        /// </summary>
+        /// <remarks>
+        /// Call this after making a series of one or more calls to Deflate(). All buffers are flushed.
+        /// </remarks>
+        /// <returns>Z_OK if all goes well.</returns>
+        internal int EndDeflate()
+        {
+            if (dstate == null)
+                throw new ZlibException("No Deflate State!");
+            // TODO: dinoch Tue, 03 Nov 2009  15:39 (test this)
+            //int ret = dstate.End();
+            dstate = null;
+            return ZlibConstants.Z_OK; //ret;
+        }
+
+        /// <summary>
+        /// Reset a codec for another deflation session.
+        /// </summary>
+        /// <remarks>
+        /// Call this to reset the deflation state.  For example if a thread is deflating
+        /// non-consecutive blocks, you can call Reset() after the Deflate(Sync) of the first
+        /// block and before the next Deflate(None) of the second block.
+        /// </remarks>
+        /// <returns>Z_OK if all goes well.</returns>
+        internal void ResetDeflate()
+        {
+            if (dstate == null)
+                throw new ZlibException("No Deflate State!");
+            dstate.Reset();
+        }
+
+
+        /// <summary>
+        /// Set the CompressionStrategy and CompressionLevel for a deflation session.
+        /// </summary>
+        /// <param name="level">the level of compression to use.</param>
+        /// <param name="strategy">the strategy to use for compression.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        internal int SetDeflateParams(CompressionLevel level, CompressionStrategy strategy)
+        {
+            if (dstate == null)
+                throw new ZlibException("No Deflate State!");
+            return dstate.SetParams(level, strategy);
+        }
+
+
+        /// <summary>
+        /// Set the dictionary to be used for either Inflation or Deflation.
+        /// </summary>
+        /// <param name="dictionary">The dictionary bytes to use.</param>
+        /// <returns>Z_OK if all goes well.</returns>
+        internal int SetDictionary(byte[] dictionary)
+        {
+            if (istate != null)
+                return istate.SetDictionary(dictionary);
+
+            if (dstate != null)
+                return dstate.SetDictionary(dictionary);
+
+            throw new ZlibException("No Inflate or Deflate state!");
+        }
+
+        // Flush as much pending output as possible. All deflate() output goes
+        // through this function so some applications may wish to modify it
+        // to avoid allocating a large strm->next_out buffer and copying into it.
+        // (See also read_buf()).
+        internal void flush_pending()
+        {
+            int len = dstate.pendingCount;
+
+            if (len > AvailableBytesOut)
+                len = AvailableBytesOut;
+            if (len == 0)
+                return;
+
+            if (dstate.pending.Length <= dstate.nextPending ||
+                OutputBuffer.Length <= NextOut ||
+                dstate.pending.Length < (dstate.nextPending + len) ||
+                OutputBuffer.Length < (NextOut + len))
+            {
+                throw new ZlibException(String.Format("Invalid State. (pending.Length={0}, pendingCount={1})",
+                    dstate.pending.Length, dstate.pendingCount));
+            }
+
+            Array.Copy(dstate.pending, dstate.nextPending, OutputBuffer, NextOut, len);
+
+            NextOut += len;
+            dstate.nextPending += len;
+            TotalBytesOut += len;
+            AvailableBytesOut -= len;
+            dstate.pendingCount -= len;
+            if (dstate.pendingCount == 0)
+            {
+                dstate.nextPending = 0;
+            }
+        }
+
+        // Read a new buffer from the current input stream, update the adler32
+        // and total number of bytes read.  All deflate() input goes through
+        // this function so some applications may wish to modify it to avoid
+        // allocating a large strm->next_in buffer and copying from it.
+        // (See also flush_pending()).
+        internal int read_buf(byte[] buf, int start, int size)
+        {
+            int len = AvailableBytesIn;
+
+            if (len > size)
+                len = size;
+            if (len == 0)
+                return 0;
+
+            AvailableBytesIn -= len;
+
+            if (dstate.WantRfc1950HeaderBytes)
+            {
+                _Adler32 = Adler.Adler32(_Adler32, InputBuffer, NextIn, len);
+            }
+            Array.Copy(InputBuffer, NextIn, buf, start, len);
+            NextIn += len;
+            TotalBytesIn += len;
+            return len;
+        }
+
+    }
+
+    internal enum ZlibStreamFlavor { ZLIB = 1950, DEFLATE = 1951, GZIP = 1952 }
+
+    internal class ZlibBaseStream : System.IO.Stream
+    {
+        protected internal ZlibCodec _z = null; // deferred init... new ZlibCodec();
+
+        protected internal StreamMode _streamMode = StreamMode.Undefined;
+        protected internal FlushType _flushMode;
+        protected internal ZlibStreamFlavor _flavor;
+        protected internal CompressionMode _compressionMode;
+        protected internal CompressionLevel _level;
+        protected internal bool _leaveOpen;
+        protected internal byte[] _workingBuffer;
+        protected internal int _bufferSize = ZlibConstants.WorkingBufferSizeDefault;
+        protected internal byte[] _buf1 = new byte[1];
+
+        protected internal System.IO.Stream _stream;
+        protected internal CompressionStrategy Strategy = CompressionStrategy.Default;
+
+        // workitem 7159
+        CRC32 crc;
+        protected internal string _GzipFileName;
+        protected internal string _GzipComment;
+        protected internal DateTime _GzipMtime;
+        protected internal int _gzipHeaderByteCount;
+
+        internal int Crc32 { get { if (crc == null) return 0; return crc.Crc32Result; } }
+
+        internal ZlibBaseStream(System.IO.Stream stream,
+                              CompressionMode compressionMode,
+                              CompressionLevel level,
+                              ZlibStreamFlavor flavor,
+                              bool leaveOpen)
+            : base()
+        {
+            this._flushMode = FlushType.None;
+            //this._workingBuffer = new byte[WORKING_BUFFER_SIZE_DEFAULT];
+            this._stream = stream;
+            this._leaveOpen = leaveOpen;
+            this._compressionMode = compressionMode;
+            this._flavor = flavor;
+            this._level = level;
+            // workitem 7159
+            if (flavor == ZlibStreamFlavor.GZIP)
+            {
+                this.crc = new CRC32();
+            }
+        }
+
+
+        protected internal bool _wantCompress
+        {
+            get
+            {
+                return (this._compressionMode == CompressionMode.Compress);
+            }
+        }
+
+        private ZlibCodec z
+        {
+            get
+            {
+                if (_z == null)
+                {
+                    bool wantRfc1950Header = (this._flavor == ZlibStreamFlavor.ZLIB);
+                    _z = new ZlibCodec();
+                    if (this._compressionMode == CompressionMode.Decompress)
+                    {
+                        _z.InitializeInflate(wantRfc1950Header);
+                    }
+                    else
+                    {
+                        _z.Strategy = Strategy;
+                        _z.InitializeDeflate(this._level, wantRfc1950Header);
+                    }
+                }
+                return _z;
+            }
+        }
+
+
+
+        private byte[] workingBuffer
+        {
+            get
+            {
+                if (_workingBuffer == null)
+                    _workingBuffer = new byte[_bufferSize];
+                return _workingBuffer;
+            }
+        }
+
+        public override void Write(System.Byte[] buffer, int offset, int count)
+        {
+            // workitem 7159
+            // calculate the CRC on the unccompressed data  (before writing)
+            if (crc != null)
+                crc.SlurpBlock(buffer, offset, count);
+
+            if (_streamMode == StreamMode.Undefined)
+                _streamMode = StreamMode.Writer;
+            else if (_streamMode != StreamMode.Writer)
+                throw new ZlibException("Cannot Write after Reading.");
+
+            if (count == 0)
+                return;
+
+            // first reference of z property will initialize the private var _z
+            z.InputBuffer = buffer;
+            _z.NextIn = offset;
+            _z.AvailableBytesIn = count;
+            bool done = false;
+            do
+            {
+                _z.OutputBuffer = workingBuffer;
+                _z.NextOut = 0;
+                _z.AvailableBytesOut = _workingBuffer.Length;
+                int rc = (_wantCompress)
+                    ? _z.Deflate(_flushMode)
+                    : _z.Inflate(_flushMode);
+                if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
+                    throw new ZlibException((_wantCompress ? "de" : "in") + "flating: " + _z.Message);
+
+                //if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
+                _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut);
+
+                done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;
+
+                // If GZIP and de-compress, we're done when 8 bytes remain.
+                if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
+                    done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);
+
+            }
+            while (!done);
+        }
+
+
+
+        private void finish()
+        {
+            if (_z == null) return;
+
+            if (_streamMode == StreamMode.Writer)
+            {
+                bool done = false;
+                do
+                {
+                    _z.OutputBuffer = workingBuffer;
+                    _z.NextOut = 0;
+                    _z.AvailableBytesOut = _workingBuffer.Length;
+                    int rc = (_wantCompress)
+                        ? _z.Deflate(FlushType.Finish)
+                        : _z.Inflate(FlushType.Finish);
+
+                    if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
+                    {
+                        string verb = (_wantCompress ? "de" : "in") + "flating";
+                        if (_z.Message == null)
+                            throw new ZlibException(String.Format("{0}: (rc = {1})", verb, rc));
+                        else
+                            throw new ZlibException(verb + ": " + _z.Message);
+                    }
+
+                    if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
+                    {
+                        _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut);
+                    }
+
+                    done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;
+                    // If GZIP and de-compress, we're done when 8 bytes remain.
+                    if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
+                        done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);
+
+                }
+                while (!done);
+
+                Flush();
+
+                // workitem 7159
+                if (_flavor == ZlibStreamFlavor.GZIP)
+                {
+                    if (_wantCompress)
+                    {
+                        // Emit the GZIP trailer: CRC32 and  size mod 2^32
+                        int c1 = crc.Crc32Result;
+                        _stream.Write(BitConverter.GetBytes(c1), 0, 4);
+                        int c2 = (Int32)(crc.TotalBytesRead & 0x00000000FFFFFFFF);
+                        _stream.Write(BitConverter.GetBytes(c2), 0, 4);
+                    }
+                    else
+                    {
+                        throw new ZlibException("Writing with decompression is not supported.");
+                    }
+                }
+            }
+            // workitem 7159
+            else if (_streamMode == StreamMode.Reader)
+            {
+                if (_flavor == ZlibStreamFlavor.GZIP)
+                {
+                    if (!_wantCompress)
+                    {
+                        // workitem 8501: handle edge case (decompress empty stream)
+                        if (_z.TotalBytesOut == 0L)
+                            return;
+
+                        // Read and potentially verify the GZIP trailer:
+                        // CRC32 and size mod 2^32
+                        byte[] trailer = new byte[8];
+
+                        // workitems 8679 & 12554
+                        if (_z.AvailableBytesIn < 8)
+                        {
+                            // Make sure we have read to the end of the stream
+                            Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, _z.AvailableBytesIn);
+                            int bytesNeeded = 8 - _z.AvailableBytesIn;
+                            int bytesRead = _stream.Read(trailer,
+                                                         _z.AvailableBytesIn,
+                                                         bytesNeeded);
+                            if (bytesNeeded != bytesRead)
+                            {
+                                throw new ZlibException(String.Format("Missing or incomplete GZIP trailer. Expected 8 bytes, got {0}.",
+                                                                      _z.AvailableBytesIn + bytesRead));
+                            }
+                        }
+                        else
+                        {
+                            Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, trailer.Length);
+                        }
+
+                        Int32 crc32_expected = BitConverter.ToInt32(trailer, 0);
+                        Int32 crc32_actual = crc.Crc32Result;
+                        Int32 isize_expected = BitConverter.ToInt32(trailer, 4);
+                        Int32 isize_actual = (Int32)(_z.TotalBytesOut & 0x00000000FFFFFFFF);
+
+                        if (crc32_actual != crc32_expected)
+                            throw new ZlibException(String.Format("Bad CRC32 in GZIP trailer. (actual({0:X8})!=expected({1:X8}))", crc32_actual, crc32_expected));
+
+                        if (isize_actual != isize_expected)
+                            throw new ZlibException(String.Format("Bad size in GZIP trailer. (actual({0})!=expected({1}))", isize_actual, isize_expected));
+
+                    }
+                    else
+                    {
+                        throw new ZlibException("Reading with compression is not supported.");
+                    }
+                }
+            }
+        }
+
+
+        private void end()
+        {
+            if (z == null)
+                return;
+            if (_wantCompress)
+            {
+                _z.EndDeflate();
+            }
+            else
+            {
+                _z.EndInflate();
+            }
+            _z = null;
+        }
+
+        public override void Flush()
+        {
+            _stream.Flush();
+        }
+
+        public override System.Int64 Seek(System.Int64 offset, System.IO.SeekOrigin origin)
+        {
+            throw new NotImplementedException();
+            //_outStream.Seek(offset, origin);
+        }
+        public override void SetLength(System.Int64 value)
+        {
+            _stream.SetLength(value);
+        }
+
+
+#if NOT
+        internal int Read()
+        {
+            if (Read(_buf1, 0, 1) == 0)
+                return 0;
+            // calculate CRC after reading
+            if (crc!=null)
+                crc.SlurpBlock(_buf1,0,1);
+            return (_buf1[0] & 0xFF);
+        }
+#endif
+
+        private bool nomoreinput = false;
+
+
+
+        private string ReadZeroTerminatedString()
+        {
+            var list = new System.Collections.Generic.List<byte>();
+            bool done = false;
+            do
+            {
+                // workitem 7740
+                int n = _stream.Read(_buf1, 0, 1);
+                if (n != 1)
+                    throw new ZlibException("Unexpected EOF reading GZIP header.");
+                else
+                {
+                    if (_buf1[0] == 0)
+                        done = true;
+                    else
+                        list.Add(_buf1[0]);
+                }
+            } while (!done);
+            byte[] a = list.ToArray();
+            return GZipStream.iso8859dash1.GetString(a, 0, a.Length);
+        }
+
+
+        private int _ReadAndValidateGzipHeader()
+        {
+            int totalBytesRead = 0;
+            // read the header on the first read
+            byte[] header = new byte[10];
+            int n = _stream.Read(header, 0, header.Length);
+
+            // workitem 8501: handle edge case (decompress empty stream)
+            if (n == 0)
+                return 0;
+
+            if (n != 10)
+                throw new ZlibException("Not a valid GZIP stream.");
+
+            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+                throw new ZlibException("Bad GZIP header.");
+
+            Int32 timet = BitConverter.ToInt32(header, 4);
+            _GzipMtime = GZipStream._unixEpoch.AddSeconds(timet);
+            totalBytesRead += n;
+            if ((header[3] & 0x04) == 0x04)
+            {
+                // read and discard extra field
+                n = _stream.Read(header, 0, 2); // 2-byte length field
+                totalBytesRead += n;
+
+                Int16 extraLength = (Int16)(header[0] + header[1] * 256);
+                byte[] extra = new byte[extraLength];
+                n = _stream.Read(extra, 0, extra.Length);
+                if (n != extraLength)
+                    throw new ZlibException("Unexpected end-of-file reading GZIP header.");
+                totalBytesRead += n;
+            }
+            if ((header[3] & 0x08) == 0x08)
+                _GzipFileName = ReadZeroTerminatedString();
+            if ((header[3] & 0x10) == 0x010)
+                _GzipComment = ReadZeroTerminatedString();
+            if ((header[3] & 0x02) == 0x02)
+                Read(_buf1, 0, 1); // CRC16, ignore
+
+            return totalBytesRead;
+        }
+
+
+
+        public override System.Int32 Read(System.Byte[] buffer, System.Int32 offset, System.Int32 count)
+        {
+            // According to MS documentation, any implementation of the IO.Stream.Read function must:
+            // (a) throw an exception if offset & count reference an invalid part of the buffer,
+            //     or if count < 0, or if buffer is null
+            // (b) return 0 only upon EOF, or if count = 0
+            // (c) if not EOF, then return at least 1 byte, up to <count> bytes
+
+            if (_streamMode == StreamMode.Undefined)
+            {
+                if (!this._stream.CanRead) throw new ZlibException("The stream is not readable.");
+                // for the first read, set up some controls.
+                _streamMode = StreamMode.Reader;
+                // (The first reference to _z goes through the private accessor which
+                // may initialize it.)
+                z.AvailableBytesIn = 0;
+                if (_flavor == ZlibStreamFlavor.GZIP)
+                {
+                    _gzipHeaderByteCount = _ReadAndValidateGzipHeader();
+                    // workitem 8501: handle edge case (decompress empty stream)
+                    if (_gzipHeaderByteCount == 0)
+                        return 0;
+                }
+            }
+
+            if (_streamMode != StreamMode.Reader)
+                throw new ZlibException("Cannot Read after Writing.");
+
+            if (count == 0) return 0;
+            if (nomoreinput && _wantCompress) return 0;  // workitem 8557
+            if (buffer == null) throw new ArgumentNullException("buffer");
+            if (count < 0) throw new ArgumentOutOfRangeException("count");
+            if (offset < buffer.GetLowerBound(0)) throw new ArgumentOutOfRangeException("offset");
+            if ((offset + count) > buffer.GetLength(0)) throw new ArgumentOutOfRangeException("count");
+
+            int rc = 0;
+
+            // set up the output of the deflate/inflate codec:
+            _z.OutputBuffer = buffer;
+            _z.NextOut = offset;
+            _z.AvailableBytesOut = count;
+
+            // This is necessary in case _workingBuffer has been resized. (new byte[])
+            // (The first reference to _workingBuffer goes through the private accessor which
+            // may initialize it.)
+            _z.InputBuffer = workingBuffer;
+
+            do
+            {
+                // need data in _workingBuffer in order to deflate/inflate.  Here, we check if we have any.
+                if ((_z.AvailableBytesIn == 0) && (!nomoreinput))
+                {
+                    // No data available, so try to Read data from the captive stream.
+                    _z.NextIn = 0;
+                    _z.AvailableBytesIn = _stream.Read(_workingBuffer, 0, _workingBuffer.Length);
+                    if (_z.AvailableBytesIn == 0)
+                        nomoreinput = true;
+
+                }
+                // we have data in InputBuffer; now compress or decompress as appropriate
+                rc = (_wantCompress)
+                    ? _z.Deflate(_flushMode)
+                    : _z.Inflate(_flushMode);
+
+                if (nomoreinput && (rc == ZlibConstants.Z_BUF_ERROR))
+                    return 0;
+
+                if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
+                    throw new ZlibException(String.Format("{0}flating:  rc={1}  msg={2}", (_wantCompress ? "de" : "in"), rc, _z.Message));
+
+                if ((nomoreinput || rc == ZlibConstants.Z_STREAM_END) && (_z.AvailableBytesOut == count))
+                    break; // nothing more to read
+            }
+            //while (_z.AvailableBytesOut == count && rc == ZlibConstants.Z_OK);
+            while (_z.AvailableBytesOut > 0 && !nomoreinput && rc == ZlibConstants.Z_OK);
+
+
+            // workitem 8557
+            // is there more room in output?
+            if (_z.AvailableBytesOut > 0)
+            {
+                if (rc == ZlibConstants.Z_OK && _z.AvailableBytesIn == 0)
+                {
+                    // deferred
+                }
+
+                // are we completely done reading?
+                if (nomoreinput)
+                {
+                    // and in compression?
+                    if (_wantCompress)
+                    {
+                        // no more input data available; therefore we flush to
+                        // try to complete the read
+                        rc = _z.Deflate(FlushType.Finish);
+
+                        if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
+                            throw new ZlibException(String.Format("Deflating:  rc={0}  msg={1}", rc, _z.Message));
+                    }
+                }
+            }
+
+
+            rc = (count - _z.AvailableBytesOut);
+
+            // calculate CRC after reading
+            if (crc != null)
+                crc.SlurpBlock(buffer, offset, rc);
+
+            return rc;
+        }
+
+
+
+        public override System.Boolean CanRead
+        {
+            get { return this._stream.CanRead; }
+        }
+
+        public override System.Boolean CanSeek
+        {
+            get { return this._stream.CanSeek; }
+        }
+
+        public override System.Boolean CanWrite
+        {
+            get { return this._stream.CanWrite; }
+        }
+
+        public override System.Int64 Length
+        {
+            get { return _stream.Length; }
+        }
+
+        public override long Position
+        {
+            get { throw new NotImplementedException(); }
+            set { throw new NotImplementedException(); }
+        }
+
+        internal enum StreamMode
+        {
+            Writer,
+            Reader,
+            Undefined,
+        }
+
+
+        internal static void CompressString(String s, Stream compressor)
+        {
+            byte[] uncompressed = System.Text.Encoding.UTF8.GetBytes(s);
+            using (compressor)
+            {
+                compressor.Write(uncompressed, 0, uncompressed.Length);
+            }
+        }
+
+        internal static void CompressBuffer(byte[] b, Stream compressor)
+        {
+            // workitem 8460
+            using (compressor)
+            {
+                compressor.Write(b, 0, b.Length);
+            }
+        }
+
+        internal static String UncompressString(byte[] compressed, Stream decompressor)
+        {
+            // workitem 8460
+            byte[] working = new byte[1024];
+            var encoding = System.Text.Encoding.UTF8;
+            using (var output = new MemoryStream())
+            {
+                using (decompressor)
+                {
+                    int n;
+                    while ((n = decompressor.Read(working, 0, working.Length)) != 0)
+                    {
+                        output.Write(working, 0, n);
+                    }
+                }
+
+                // reset to allow read from start
+                output.Seek(0, SeekOrigin.Begin);
+                var sr = new StreamReader(output, encoding);
+                return sr.ReadToEnd();
+            }
+        }
+
+        internal static byte[] UncompressBuffer(byte[] compressed, Stream decompressor)
+        {
+            // workitem 8460
+            byte[] working = new byte[1024];
+            using (var output = new MemoryStream())
+            {
+                using (decompressor)
+                {
+                    int n;
+                    while ((n = decompressor.Read(working, 0, working.Length)) != 0)
+                    {
+                        output.Write(working, 0, n);
+                    }
+                }
+                return output.ToArray();
+            }
+        }
+
+    }
+
+    /// <summary>
+    /// Describes how to flush the current deflate operation.
+    /// </summary>
+    /// <remarks>
+    /// The different FlushType values are useful when using a Deflate in a streaming application.
+    /// </remarks>
+    public enum FlushType
+    {
+        /// <summary>No flush at all.</summary>
+        None = 0,
+
+        /// <summary>Closes the current block, but doesn't flush it to
+        /// the output. Used internally only in hypothetical
+        /// scenarios.  This was supposed to be removed by Zlib, but it is
+        /// still in use in some edge cases.
+        /// </summary>
+        Partial,
+
+        /// <summary>
+        /// Use this during compression to specify that all pending output should be
+        /// flushed to the output buffer and the output should be aligned on a byte
+        /// boundary.  You might use this in a streaming communication scenario, so that
+        /// the decompressor can get all input data available so far.  When using this
+        /// with a ZlibCodec, <c>AvailableBytesIn</c> will be zero after the call if
+        /// enough output space has been provided before the call.  Flushing will
+        /// degrade compression and so it should be used only when necessary.
+        /// </summary>
+        Sync,
+
+        /// <summary>
+        /// Use this during compression to specify that all output should be flushed, as
+        /// with <c>FlushType.Sync</c>, but also, the compression state should be reset
+        /// so that decompression can restart from this point if previous compressed
+        /// data has been damaged or if random access is desired.  Using
+        /// <c>FlushType.Full</c> too often can significantly degrade the compression.
+        /// </summary>
+        Full,
+
+        /// <summary>Signals the end of the compression/decompression stream.</summary>
+        Finish,
+    }
+
+
+    /// <summary>
+    /// The compression level to be used when using a DeflateStream or ZlibStream with CompressionMode.Compress.
+    /// </summary>
+    public enum CompressionLevel
+    {
+        /// <summary>
+        /// None means that the data will be simply stored, with no change at all.
+        /// If you are producing ZIPs for use on Mac OSX, be aware that archives produced with CompressionLevel.None
+        /// cannot be opened with the default zip reader. Use a different CompressionLevel.
+        /// </summary>
+        None = 0,
+        /// <summary>
+        /// Same as None.
+        /// </summary>
+        Level0 = 0,
+
+        /// <summary>
+        /// The fastest but least effective compression.
+        /// </summary>
+        BestSpeed = 1,
+
+        /// <summary>
+        /// A synonym for BestSpeed.
+        /// </summary>
+        Level1 = 1,
+
+        /// <summary>
+        /// A little slower, but better, than level 1.
+        /// </summary>
+        Level2 = 2,
+
+        /// <summary>
+        /// A little slower, but better, than level 2.
+        /// </summary>
+        Level3 = 3,
+
+        /// <summary>
+        /// A little slower, but better, than level 3.
+        /// </summary>
+        Level4 = 4,
+
+        /// <summary>
+        /// A little slower than level 4, but with better compression.
+        /// </summary>
+        Level5 = 5,
+
+        /// <summary>
+        /// The default compression level, with a good balance of speed and compression efficiency.
+        /// </summary>
+        Default = 6,
+        /// <summary>
+        /// A synonym for Default.
+        /// </summary>
+        Level6 = 6,
+
+        /// <summary>
+        /// Pretty good compression!
+        /// </summary>
+        Level7 = 7,
+
+        /// <summary>
+        ///  Better compression than Level7!
+        /// </summary>
+        Level8 = 8,
+
+        /// <summary>
+        /// The "best" compression, where best means greatest reduction in size of the input data stream.
+        /// This is also the slowest compression.
+        /// </summary>
+        BestCompression = 9,
+
+        /// <summary>
+        /// A synonym for BestCompression.
+        /// </summary>
+        Level9 = 9,
+    }
+
+    /// <summary>
+    /// Describes options for how the compression algorithm is executed.  Different strategies
+    /// work better on different sorts of data.  The strategy parameter can affect the compression
+    /// ratio and the speed of compression but not the correctness of the compresssion.
+    /// </summary>
+    internal enum CompressionStrategy
+    {
+        /// <summary>
+        /// The default strategy is probably the best for normal data.
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        /// The <c>Filtered</c> strategy is intended to be used most effectively with data produced by a
+        /// filter or predictor.  By this definition, filtered data consists mostly of small
+        /// values with a somewhat random distribution.  In this case, the compression algorithm
+        /// is tuned to compress them better.  The effect of <c>Filtered</c> is to force more Huffman
+        /// coding and less string matching; it is a half-step between <c>Default</c> and <c>HuffmanOnly</c>.
+        /// </summary>
+        Filtered = 1,
+
+        /// <summary>
+        /// Using <c>HuffmanOnly</c> will force the compressor to do Huffman encoding only, with no
+        /// string matching.
+        /// </summary>
+        HuffmanOnly = 2,
+    }
+
+
+    /// <summary>
+    /// An enum to specify the direction of transcoding - whether to compress or decompress.
+    /// </summary>
+    public enum CompressionMode
+    {
+        /// <summary>
+        /// Used to specify that the stream should compress the data.
+        /// </summary>
+        Compress = 0,
+        /// <summary>
+        /// Used to specify that the stream should decompress the data.
+        /// </summary>
+        Decompress = 1,
+    }
+
+
+    /// <summary>
+    /// A general purpose exception class for exceptions in the Zlib library.
+    /// </summary>
+    internal class ZlibException : System.Exception
+    {
+        /// <summary>
+        /// The ZlibException class captures exception information generated
+        /// by the Zlib library.
+        /// </summary>
+        internal ZlibException()
+            : base()
+        {
+        }
+
+        /// <summary>
+        /// This ctor collects a message attached to the exception.
+        /// </summary>
+        /// <param name="s">the message for the exception.</param>
+        internal ZlibException(System.String s)
+            : base(s)
+        {
+        }
+    }
+
+
+    internal class SharedUtils
+    {
+        /// <summary>
+        /// Performs an unsigned bitwise right shift with the specified number
+        /// </summary>
+        /// <param name="number">Number to operate on</param>
+        /// <param name="bits">Ammount of bits to shift</param>
+        /// <returns>The resulting number from the shift operation</returns>
+        internal static int URShift(int number, int bits)
+        {
+            return (int)((uint)number >> bits);
+        }
+
+#if NOT
+        /// <summary>
+        /// Performs an unsigned bitwise right shift with the specified number
+        /// </summary>
+        /// <param name="number">Number to operate on</param>
+        /// <param name="bits">Ammount of bits to shift</param>
+        /// <returns>The resulting number from the shift operation</returns>
+        internal static long URShift(long number, int bits)
+        {
+            return (long) ((UInt64)number >> bits);
+        }
+#endif
+
+        /// <summary>
+        ///   Reads a number of characters from the current source TextReader and writes
+        ///   the data to the target array at the specified index.
+        /// </summary>
+        ///
+        /// <param name="sourceTextReader">The source TextReader to read from</param>
+        /// <param name="target">Contains the array of characteres read from the source TextReader.</param>
+        /// <param name="start">The starting index of the target array.</param>
+        /// <param name="count">The maximum number of characters to read from the source TextReader.</param>
+        ///
+        /// <returns>
+        ///   The number of characters read. The number will be less than or equal to
+        ///   count depending on the data available in the source TextReader. Returns -1
+        ///   if the end of the stream is reached.
+        /// </returns>
+        internal static System.Int32 ReadInput(System.IO.TextReader sourceTextReader, byte[] target, int start, int count)
+        {
+            // Returns 0 bytes if not enough space in target
+            if (target.Length == 0) return 0;
+
+            char[] charArray = new char[target.Length];
+            int bytesRead = sourceTextReader.Read(charArray, start, count);
+
+            // Returns -1 if EOF
+            if (bytesRead == 0) return -1;
+
+            for (int index = start; index < start + bytesRead; index++)
+                target[index] = (byte)charArray[index];
+
+            return bytesRead;
+        }
+
+
+        internal static byte[] ToByteArray(System.String sourceString)
+        {
+            return System.Text.UTF8Encoding.UTF8.GetBytes(sourceString);
+        }
+
+
+        internal static char[] ToCharArray(byte[] byteArray)
+        {
+            return System.Text.UTF8Encoding.UTF8.GetChars(byteArray);
+        }
+    }
+
+    internal static class InternalConstants
+    {
+        internal static readonly int MAX_BITS = 15;
+        internal static readonly int BL_CODES = 19;
+        internal static readonly int D_CODES = 30;
+        internal static readonly int LITERALS = 256;
+        internal static readonly int LENGTH_CODES = 29;
+        internal static readonly int L_CODES = (LITERALS + 1 + LENGTH_CODES);
+
+        // Bit length codes must not exceed MAX_BL_BITS bits
+        internal static readonly int MAX_BL_BITS = 7;
+
+        // repeat previous bit length 3-6 times (2 bits of repeat count)
+        internal static readonly int REP_3_6 = 16;
+
+        // repeat a zero length 3-10 times  (3 bits of repeat count)
+        internal static readonly int REPZ_3_10 = 17;
+
+        // repeat a zero length 11-138 times  (7 bits of repeat count)
+        internal static readonly int REPZ_11_138 = 18;
+
+    }
+
+    internal sealed class StaticTree
+    {
+        internal static readonly short[] lengthAndLiteralsTreeCodes = new short[] {
+            12, 8, 140, 8, 76, 8, 204, 8, 44, 8, 172, 8, 108, 8, 236, 8,
+            28, 8, 156, 8, 92, 8, 220, 8, 60, 8, 188, 8, 124, 8, 252, 8,
+             2, 8, 130, 8, 66, 8, 194, 8, 34, 8, 162, 8, 98, 8, 226, 8,
+            18, 8, 146, 8, 82, 8, 210, 8, 50, 8, 178, 8, 114, 8, 242, 8,
+            10, 8, 138, 8, 74, 8, 202, 8, 42, 8, 170, 8, 106, 8, 234, 8,
+            26, 8, 154, 8, 90, 8, 218, 8, 58, 8, 186, 8, 122, 8, 250, 8,
+             6, 8, 134, 8, 70, 8, 198, 8, 38, 8, 166, 8, 102, 8, 230, 8,
+            22, 8, 150, 8, 86, 8, 214, 8, 54, 8, 182, 8, 118, 8, 246, 8,
+            14, 8, 142, 8, 78, 8, 206, 8, 46, 8, 174, 8, 110, 8, 238, 8,
+            30, 8, 158, 8, 94, 8, 222, 8, 62, 8, 190, 8, 126, 8, 254, 8,
+             1, 8, 129, 8, 65, 8, 193, 8, 33, 8, 161, 8, 97, 8, 225, 8,
+            17, 8, 145, 8, 81, 8, 209, 8, 49, 8, 177, 8, 113, 8, 241, 8,
+             9, 8, 137, 8, 73, 8, 201, 8, 41, 8, 169, 8, 105, 8, 233, 8,
+            25, 8, 153, 8, 89, 8, 217, 8, 57, 8, 185, 8, 121, 8, 249, 8,
+             5, 8, 133, 8, 69, 8, 197, 8, 37, 8, 165, 8, 101, 8, 229, 8,
+            21, 8, 149, 8, 85, 8, 213, 8, 53, 8, 181, 8, 117, 8, 245, 8,
+            13, 8, 141, 8, 77, 8, 205, 8, 45, 8, 173, 8, 109, 8, 237, 8,
+            29, 8, 157, 8, 93, 8, 221, 8, 61, 8, 189, 8, 125, 8, 253, 8,
+            19, 9, 275, 9, 147, 9, 403, 9, 83, 9, 339, 9, 211, 9, 467, 9,
+            51, 9, 307, 9, 179, 9, 435, 9, 115, 9, 371, 9, 243, 9, 499, 9,
+            11, 9, 267, 9, 139, 9, 395, 9, 75, 9, 331, 9, 203, 9, 459, 9,
+            43, 9, 299, 9, 171, 9, 427, 9, 107, 9, 363, 9, 235, 9, 491, 9,
+            27, 9, 283, 9, 155, 9, 411, 9, 91, 9, 347, 9, 219, 9, 475, 9,
+            59, 9, 315, 9, 187, 9, 443, 9, 123, 9, 379, 9, 251, 9, 507, 9,
+             7, 9, 263, 9, 135, 9, 391, 9, 71, 9, 327, 9, 199, 9, 455, 9,
+            39, 9, 295, 9, 167, 9, 423, 9, 103, 9, 359, 9, 231, 9, 487, 9,
+            23, 9, 279, 9, 151, 9, 407, 9, 87, 9, 343, 9, 215, 9, 471, 9,
+            55, 9, 311, 9, 183, 9, 439, 9, 119, 9, 375, 9, 247, 9, 503, 9,
+            15, 9, 271, 9, 143, 9, 399, 9, 79, 9, 335, 9, 207, 9, 463, 9,
+            47, 9, 303, 9, 175, 9, 431, 9, 111, 9, 367, 9, 239, 9, 495, 9,
+            31, 9, 287, 9, 159, 9, 415, 9, 95, 9, 351, 9, 223, 9, 479, 9,
+            63, 9, 319, 9, 191, 9, 447, 9, 127, 9, 383, 9, 255, 9, 511, 9,
+             0, 7, 64, 7, 32, 7, 96, 7, 16, 7, 80, 7, 48, 7, 112, 7,
+             8, 7, 72, 7, 40, 7, 104, 7, 24, 7, 88, 7, 56, 7, 120, 7,
+             4, 7, 68, 7, 36, 7, 100, 7, 20, 7, 84, 7, 52, 7, 116, 7,
+             3, 8, 131, 8, 67, 8, 195, 8, 35, 8, 163, 8, 99, 8, 227, 8
+        };
+
+        internal static readonly short[] distTreeCodes = new short[] {
+            0, 5, 16, 5, 8, 5, 24, 5, 4, 5, 20, 5, 12, 5, 28, 5,
+            2, 5, 18, 5, 10, 5, 26, 5, 6, 5, 22, 5, 14, 5, 30, 5,
+            1, 5, 17, 5, 9, 5, 25, 5, 5, 5, 21, 5, 13, 5, 29, 5,
+            3, 5, 19, 5, 11, 5, 27, 5, 7, 5, 23, 5 };
+
+        internal static readonly StaticTree Literals;
+        internal static readonly StaticTree Distances;
+        internal static readonly StaticTree BitLengths;
+
+        internal short[] treeCodes; // static tree or null
+        internal int[] extraBits;   // extra bits for each code or null
+        internal int extraBase;     // base index for extra_bits
+        internal int elems;         // max number of elements in the tree
+        internal int maxLength;     // max bit length for the codes
+
+        private StaticTree(short[] treeCodes, int[] extraBits, int extraBase, int elems, int maxLength)
+        {
+            this.treeCodes = treeCodes;
+            this.extraBits = extraBits;
+            this.extraBase = extraBase;
+            this.elems = elems;
+            this.maxLength = maxLength;
+        }
+        static StaticTree()
+        {
+            Literals = new StaticTree(lengthAndLiteralsTreeCodes, Tree.ExtraLengthBits, InternalConstants.LITERALS + 1, InternalConstants.L_CODES, InternalConstants.MAX_BITS);
+            Distances = new StaticTree(distTreeCodes, Tree.ExtraDistanceBits, 0, InternalConstants.D_CODES, InternalConstants.MAX_BITS);
+            BitLengths = new StaticTree(null, Tree.extra_blbits, 0, InternalConstants.BL_CODES, InternalConstants.MAX_BL_BITS);
+        }
+    }
+
+
+
+    /// <summary>
+    /// Computes an Adler-32 checksum.
+    /// </summary>
+    /// <remarks>
+    /// The Adler checksum is similar to a CRC checksum, but faster to compute, though less
+    /// reliable.  It is used in producing RFC1950 compressed streams.  The Adler checksum
+    /// is a required part of the "ZLIB" standard.  Applications will almost never need to
+    /// use this class directly.
+    /// </remarks>
+    ///
+    /// <exclude/>
+    internal sealed class Adler
+    {
+        // largest prime smaller than 65536
+        private static readonly uint BASE = 65521;
+        // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
+        private static readonly int NMAX = 5552;
+
+
+#pragma warning disable 3001
+#pragma warning disable 3002
+
+        /// <summary>
+        ///   Calculates the Adler32 checksum.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     This is used within ZLIB.  You probably don't need to use this directly.
+        ///   </para>
+        /// </remarks>
+        /// <example>
+        ///    To compute an Adler32 checksum on a byte array:
+        ///  <code>
+        ///    var adler = Adler.Adler32(0, null, 0, 0);
+        ///    adler = Adler.Adler32(adler, buffer, index, length);
+        ///  </code>
+        /// </example>
+        internal static uint Adler32(uint adler, byte[] buf, int index, int len)
+        {
+            if (buf == null)
+                return 1;
+
+            uint s1 = (uint)(adler & 0xffff);
+            uint s2 = (uint)((adler >> 16) & 0xffff);
+
+            while (len > 0)
+            {
+                int k = len < NMAX ? len : NMAX;
+                len -= k;
+                while (k >= 16)
+                {
+                    //s1 += (buf[index++] & 0xff); s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    s1 += buf[index++]; s2 += s1;
+                    k -= 16;
+                }
+                if (k != 0)
+                {
+                    do
+                    {
+                        s1 += buf[index++];
+                        s2 += s1;
+                    }
+                    while (--k != 0);
+                }
+                s1 %= BASE;
+                s2 %= BASE;
+            }
+            return (uint)((s2 << 16) | s1);
+        }
+#pragma warning restore 3001
+#pragma warning restore 3002
+
+    }
+
+    sealed class Tree
+    {
+        private static readonly int HEAP_SIZE = (2 * InternalConstants.L_CODES + 1);
+
+        // extra bits for each length code
+        internal static readonly int[] ExtraLengthBits = new int[]
+        {
+            0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+            3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
+        };
+
+        // extra bits for each distance code
+        internal static readonly int[] ExtraDistanceBits = new int[]
+        {
+            0, 0, 0, 0, 1, 1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  6,
+            7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13
+        };
+
+        // extra bits for each bit length code
+        internal static readonly int[] extra_blbits = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7 };
+
+        internal static readonly sbyte[] bl_order = new sbyte[] { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
+
+
+        // The lengths of the bit length codes are sent in order of decreasing
+        // probability, to avoid transmitting the lengths for unused bit
+        // length codes.
+
+        internal const int Buf_size = 8 * 2;
+
+        // see definition of array dist_code below
+        //internal const int DIST_CODE_LEN = 512;
+
+        private static readonly sbyte[] _dist_code = new sbyte[]
+        {
+            0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7, 
+            8,  8,  8,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9,
+            10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 
+            11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 
+            12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 
+            12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 
+            13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
+            13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
+            14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+            14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+            14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+            14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 
+            15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+            15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+            15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+            15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 
+            0,   0, 16, 17, 18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 
+            22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 
+            24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+            25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 
+            26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 
+            26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 
+            27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 
+            27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 
+            28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
+            28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
+            28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
+            28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 
+            29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
+            29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
+            29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
+            29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+        };
+
+        internal static readonly sbyte[] LengthCode = new sbyte[]
+        {
+            0,   1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11,
+            12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15,
+            16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17,
+            18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19,
+            20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+            21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+            22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+            23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+            24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+            24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+            25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+            25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+            26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+            26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+            27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+            27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+        };
+
+
+        internal static readonly int[] LengthBase = new int[]
+        {
+            0,   1,  2,  3,  4,  5,  6,   7,   8,  10,  12,  14, 16, 20, 24, 28,
+            32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 0
+        };
+
+
+        internal static readonly int[] DistanceBase = new int[]
+        {
+            0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192,
+            256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576
+        };
+
+
+        /// <summary>
+        /// Map from a distance to a distance code.
+        /// </summary>
+        /// <remarks> 
+        /// No side effects. _dist_code[256] and _dist_code[257] are never used.
+        /// </remarks>
+        internal static int DistanceCode(int dist)
+        {
+            return (dist < 256)
+                ? _dist_code[dist]
+                : _dist_code[256 + SharedUtils.URShift(dist, 7)];
+        }
+
+        internal short[] dyn_tree; // the dynamic tree
+        internal int max_code; // largest code with non zero frequency
+        internal StaticTree staticTree; // the corresponding static tree
+
+        // Compute the optimal bit lengths for a tree and update the total bit length
+        // for the current block.
+        // IN assertion: the fields freq and dad are set, heap[heap_max] and
+        //    above are the tree nodes sorted by increasing frequency.
+        // OUT assertions: the field len is set to the optimal bit length, the
+        //     array bl_count contains the frequencies for each bit length.
+        //     The length opt_len is updated; static_len is also updated if stree is
+        //     not null.
+        internal void gen_bitlen(DeflateManager s)
+        {
+            short[] tree = dyn_tree;
+            short[] stree = staticTree.treeCodes;
+            int[] extra = staticTree.extraBits;
+            int base_Renamed = staticTree.extraBase;
+            int max_length = staticTree.maxLength;
+            int h; // heap index
+            int n, m; // iterate over the tree elements
+            int bits; // bit length
+            int xbits; // extra bits
+            short f; // frequency
+            int overflow = 0; // number of elements with bit length too large
+
+            for (bits = 0; bits <= InternalConstants.MAX_BITS; bits++)
+                s.bl_count[bits] = 0;
+
+            // In a first pass, compute the optimal bit lengths (which may
+            // overflow in the case of the bit length tree).
+            tree[s.heap[s.heap_max] * 2 + 1] = 0; // root of the heap
+
+            for (h = s.heap_max + 1; h < HEAP_SIZE; h++)
+            {
+                n = s.heap[h];
+                bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;
+                if (bits > max_length)
+                {
+                    bits = max_length; overflow++;
+                }
+                tree[n * 2 + 1] = (short)bits;
+                // We overwrite tree[n*2+1] which is no longer needed
+
+                if (n > max_code)
+                    continue; // not a leaf node
+
+                s.bl_count[bits]++;
+                xbits = 0;
+                if (n >= base_Renamed)
+                    xbits = extra[n - base_Renamed];
+                f = tree[n * 2];
+                s.opt_len += f * (bits + xbits);
+                if (stree != null)
+                    s.static_len += f * (stree[n * 2 + 1] + xbits);
+            }
+            if (overflow == 0)
+                return;
+
+            // This happens for example on obj2 and pic of the Calgary corpus
+            // Find the first bit length which could increase:
+            do
+            {
+                bits = max_length - 1;
+                while (s.bl_count[bits] == 0)
+                    bits--;
+                s.bl_count[bits]--; // move one leaf down the tree
+                s.bl_count[bits + 1] = (short)(s.bl_count[bits + 1] + 2); // move one overflow item as its brother
+                s.bl_count[max_length]--;
+                // The brother of the overflow item also moves one step up,
+                // but this does not affect bl_count[max_length]
+                overflow -= 2;
+            }
+            while (overflow > 0);
+
+            for (bits = max_length; bits != 0; bits--)
+            {
+                n = s.bl_count[bits];
+                while (n != 0)
+                {
+                    m = s.heap[--h];
+                    if (m > max_code)
+                        continue;
+                    if (tree[m * 2 + 1] != bits)
+                    {
+                        s.opt_len = (int)(s.opt_len + ((long)bits - (long)tree[m * 2 + 1]) * (long)tree[m * 2]);
+                        tree[m * 2 + 1] = (short)bits;
+                    }
+                    n--;
+                }
+            }
+        }
+
+        // Construct one Huffman tree and assigns the code bit strings and lengths.
+        // Update the total bit length for the current block.
+        // IN assertion: the field freq is set for all tree elements.
+        // OUT assertions: the fields len and code are set to the optimal bit length
+        //     and corresponding code. The length opt_len is updated; static_len is
+        //     also updated if stree is not null. The field max_code is set.
+        internal void build_tree(DeflateManager s)
+        {
+            short[] tree = dyn_tree;
+            short[] stree = staticTree.treeCodes;
+            int elems = staticTree.elems;
+            int n, m;            // iterate over heap elements
+            int max_code = -1;  // largest code with non zero frequency
+            int node;            // new node being created
+
+            // Construct the initial heap, with least frequent element in
+            // heap[1]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
+            // heap[0] is not used.
+            s.heap_len = 0;
+            s.heap_max = HEAP_SIZE;
+
+            for (n = 0; n < elems; n++)
+            {
+                if (tree[n * 2] != 0)
+                {
+                    s.heap[++s.heap_len] = max_code = n;
+                    s.depth[n] = 0;
+                }
+                else
+                {
+                    tree[n * 2 + 1] = 0;
+                }
+            }
+
+            // The pkzip format requires that at least one distance code exists,
+            // and that at least one bit should be sent even if there is only one
+            // possible code. So to avoid special checks later on we force at least
+            // two codes of non zero frequency.
+            while (s.heap_len < 2)
+            {
+                node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0);
+                tree[node * 2] = 1;
+                s.depth[node] = 0;
+                s.opt_len--;
+                if (stree != null)
+                    s.static_len -= stree[node * 2 + 1];
+                // node is 0 or 1 so it does not have extra bits
+            }
+            this.max_code = max_code;
+
+            // The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
+            // establish sub-heaps of increasing lengths:
+
+            for (n = s.heap_len / 2; n >= 1; n--)
+                s.pqdownheap(tree, n);
+
+            // Construct the Huffman tree by repeatedly combining the least two
+            // frequent nodes.
+
+            node = elems; // next internal node of the tree
+            do
+            {
+                // n = node of least frequency
+                n = s.heap[1];
+                s.heap[1] = s.heap[s.heap_len--];
+                s.pqdownheap(tree, 1);
+                m = s.heap[1]; // m = node of next least frequency
+
+                s.heap[--s.heap_max] = n; // keep the nodes sorted by frequency
+                s.heap[--s.heap_max] = m;
+
+                // Create a new node father of n and m
+                tree[node * 2] = unchecked((short)(tree[n * 2] + tree[m * 2]));
+                s.depth[node] = (sbyte)(System.Math.Max((byte)s.depth[n], (byte)s.depth[m]) + 1);
+                tree[n * 2 + 1] = tree[m * 2 + 1] = (short)node;
+
+                // and insert the new node in the heap
+                s.heap[1] = node++;
+                s.pqdownheap(tree, 1);
+            }
+            while (s.heap_len >= 2);
+
+            s.heap[--s.heap_max] = s.heap[1];
+
+            // At this point, the fields freq and dad are set. We can now
+            // generate the bit lengths.
+
+            gen_bitlen(s);
+
+            // The field len is now set, we can generate the bit codes
+            gen_codes(tree, max_code, s.bl_count);
+        }
+
+        // Generate the codes for a given tree and bit counts (which need not be
+        // optimal).
+        // IN assertion: the array bl_count contains the bit length statistics for
+        // the given tree and the field len is set for all tree elements.
+        // OUT assertion: the field code is set for all tree elements of non
+        //     zero code length.
+        internal static void gen_codes(short[] tree, int max_code, short[] bl_count)
+        {
+            short[] next_code = new short[InternalConstants.MAX_BITS + 1]; // next code value for each bit length
+            short code = 0; // running code value
+            int bits; // bit index
+            int n; // code index
+
+            // The distribution counts are first used to generate the code values
+            // without bit reversal.
+            for (bits = 1; bits <= InternalConstants.MAX_BITS; bits++)
+                unchecked
+                {
+                    next_code[bits] = code = (short)((code + bl_count[bits - 1]) << 1);
+                }
+
+            // Check that the bit counts in bl_count are consistent. The last code
+            // must be all ones.
+            //Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
+            //        "inconsistent bit counts");
+            //Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
+
+            for (n = 0; n <= max_code; n++)
+            {
+                int len = tree[n * 2 + 1];
+                if (len == 0)
+                    continue;
+                // Now reverse the bits
+                tree[n * 2] = unchecked((short)(bi_reverse(next_code[len]++, len)));
+            }
+        }
+
+        // Reverse the first len bits of a code, using straightforward code (a faster
+        // method would use a table)
+        // IN assertion: 1 <= len <= 15
+        internal static int bi_reverse(int code, int len)
+        {
+            int res = 0;
+            do
+            {
+                res |= code & 1;
+                code >>= 1; //SharedUtils.URShift(code, 1);
+                res <<= 1;
+            }
+            while (--len > 0);
+            return res >> 1;
+        }
+    }
+
+    sealed class InfTree
+    {
+
+        private const int MANY = 1440;
+
+        private const int Z_OK = 0;
+        private const int Z_STREAM_END = 1;
+        private const int Z_NEED_DICT = 2;
+        private const int Z_ERRNO = -1;
+        private const int Z_STREAM_ERROR = -2;
+        private const int Z_DATA_ERROR = -3;
+        private const int Z_MEM_ERROR = -4;
+        private const int Z_BUF_ERROR = -5;
+        private const int Z_VERSION_ERROR = -6;
+
+        internal const int fixed_bl = 9;
+        internal const int fixed_bd = 5;
+
+        //UPGRADE_NOTE: Final was removed from the declaration of 'fixed_tl'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
+        internal static readonly int[] fixed_tl = new int[]{96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9, 192, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 160, 0, 8, 0, 0, 8, 128, 0, 8, 64, 0, 9, 224, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 144, 83, 7, 59, 0, 8, 120, 0, 8, 56, 0, 9, 208, 81, 7, 17, 0, 8, 104, 0, 8, 40, 0, 9, 176, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 240, 80, 7, 4, 0, 8, 84, 0, 8, 20, 85, 8, 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 200, 81, 7, 13, 0, 8, 100, 0, 8, 36, 0, 9, 168, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0, 9, 232, 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 152, 84, 7, 83, 0, 8, 124, 0, 8, 60, 0, 9, 216, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 184, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9, 248, 80, 7, 3, 0, 8, 82, 0, 8, 18, 85, 8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, 9, 196, 81, 7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 164, 0, 8, 2, 0, 8, 130, 0, 8, 66, 0, 9, 228, 80, 7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 148, 84, 7, 67, 0, 8, 122, 0, 8, 58, 0, 9, 212, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, 180, 0, 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 244, 80, 7, 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 204, 81, 7, 15, 0, 8, 102, 0, 8, 38, 0, 9, 172, 0, 8, 6, 0, 8, 134, 0, 8, 70, 0, 9, 236, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, 156, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9, 220, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 188, 0, 8, 14, 0, 8, 142, 0, 8, 78, 0, 9, 252, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0, 8, 113, 0, 8, 49, 0, 9, 194, 80, 7, 10, 0, 8, 97, 0, 8, 33, 0, 9, 162, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 226, 80, 7, 6, 0, 8, 89, 0, 8, 25, 0, 9, 146, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 210, 81, 7, 17, 0, 8, 105, 0, 8, 41, 0, 9, 178, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, 242, 80, 7, 4, 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, 117, 0, 8, 53, 0, 9, 202, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 170, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, 234, 80, 7, 8, 0, 8, 93, 0, 8, 29, 0, 9, 154, 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 218, 82, 7, 23, 0, 8, 109, 0, 8, 45, 0, 9, 186, 
+                        0, 8, 13, 0, 8, 141, 0, 8, 77, 0, 9, 250, 80, 7, 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8, 51, 0, 9, 198, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, 166, 0, 8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 230, 80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 150, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 214, 82, 7, 19, 0, 8, 107, 0, 8, 43, 0, 9, 182, 0, 8, 11, 0, 8, 139, 0, 8, 75, 0, 9, 246, 80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, 0, 9, 206, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 174, 0, 8, 7, 0, 8, 135, 0, 8, 71, 0, 9, 238, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 158, 84, 7, 99, 0, 8, 127, 0, 8, 63, 0, 9, 222, 82, 7, 27, 0, 8, 111, 0, 8, 47, 0, 9, 190, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 254, 96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9, 193, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 161, 0, 8, 0, 0, 8, 128, 0, 8, 64, 0, 9, 225, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 145, 83, 7, 59, 0, 8, 120, 0, 8, 56, 0, 9, 209, 81, 7, 17, 0, 8, 104, 0, 8, 40, 0, 9, 177, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 241, 80, 7, 4, 0, 8, 84, 0, 8, 20, 85, 8, 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 201, 81, 7, 13, 0, 8, 100, 0, 8, 36, 0, 9, 169, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0, 9, 233, 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 153, 84, 7, 83, 0, 8, 124, 0, 8, 60, 0, 9, 217, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 185, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9, 249, 80, 7, 3, 0, 8, 82, 0, 8, 18, 85, 8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, 9, 197, 81, 7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 165, 0, 8, 2, 0, 8, 130, 0, 8, 66, 0, 9, 229, 80, 7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 149, 84, 7, 67, 0, 8, 122, 0, 8, 58, 0, 9, 213, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, 181, 0, 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 245, 80, 7, 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 205, 81, 7, 15, 0, 8, 102, 0, 8, 38, 0, 9, 173, 0, 8, 6, 0, 8, 134, 0, 8, 70, 0, 9, 237, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, 157, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9, 221, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 189, 0, 8, 
+                        14, 0, 8, 142, 0, 8, 78, 0, 9, 253, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0, 8, 113, 0, 8, 49, 0, 9, 195, 80, 7, 10, 0, 8, 97, 0, 8, 33, 0, 9, 163, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 227, 80, 7, 6, 0, 8, 89, 0, 8, 25, 0, 9, 147, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 211, 81, 7, 17, 0, 8, 105, 0, 8, 41, 0, 9, 179, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, 243, 80, 7, 4, 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, 117, 0, 8, 53, 0, 9, 203, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 171, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, 235, 80, 7, 8, 0, 8, 93, 0, 8, 29, 0, 9, 155, 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 219, 82, 7, 23, 0, 8, 109, 0, 8, 45, 0, 9, 187, 0, 8, 13, 0, 8, 141, 0, 8, 77, 0, 9, 251, 80, 7, 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8, 51, 0, 9, 199, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, 167, 0, 8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 231, 80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 151, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 215, 82, 7, 19, 0, 8, 107, 0, 8, 43, 0, 9, 183, 0, 8, 11, 0, 8, 139, 0, 8, 75, 0, 9, 247, 80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, 0, 9, 207, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 175, 0, 8, 7, 0, 8, 135, 0, 8, 71, 0, 9, 239, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 159, 84, 7, 99, 0, 8, 127, 0, 8, 63, 0, 9, 223, 82, 7, 27, 0, 8, 111, 0, 8, 47, 0, 9, 191, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 255};
+        //UPGRADE_NOTE: Final was removed from the declaration of 'fixed_td'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
+        internal static readonly int[] fixed_td = new int[] { 80, 5, 1, 87, 5, 257, 83, 5, 17, 91, 5, 4097, 81, 5, 5, 89, 5, 1025, 85, 5, 65, 93, 5, 16385, 80, 5, 3, 88, 5, 513, 84, 5, 33, 92, 5, 8193, 82, 5, 9, 90, 5, 2049, 86, 5, 129, 192, 5, 24577, 80, 5, 2, 87, 5, 385, 83, 5, 25, 91, 5, 6145, 81, 5, 7, 89, 5, 1537, 85, 5, 97, 93, 5, 24577, 80, 5, 4, 88, 5, 769, 84, 5, 49, 92, 5, 12289, 82, 5, 13, 90, 5, 3073, 86, 5, 193, 192, 5, 24577 };
+
+        // Tables for deflate from PKZIP's appnote.txt.
+        //UPGRADE_NOTE: Final was removed from the declaration of 'cplens'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
+        internal static readonly int[] cplens = new int[] { 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 };
+
+        // see note #13 above about 258
+        //UPGRADE_NOTE: Final was removed from the declaration of 'cplext'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
+        internal static readonly int[] cplext = new int[] { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112 };
+
+        //UPGRADE_NOTE: Final was removed from the declaration of 'cpdist'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
+        internal static readonly int[] cpdist = new int[] { 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577 };
+
+        //UPGRADE_NOTE: Final was removed from the declaration of 'cpdext'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
+        internal static readonly int[] cpdext = new int[] { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 };
+
+        // If BMAX needs to be larger than 16, then h and x[] should be uLong.
+        internal const int BMAX = 15; // maximum bit length of any code
+
+        internal int[] hn = null; // hufts used in space
+        internal int[] v = null; // work area for huft_build 
+        internal int[] c = null; // bit length count table
+        internal int[] r = null; // table entry for structure assignment
+        internal int[] u = null; // table stack
+        internal int[] x = null; // bit offsets, then code stack
+
+        private int huft_build(int[] b, int bindex, int n, int s, int[] d, int[] e, int[] t, int[] m, int[] hp, int[] hn, int[] v)
+        {
+            // Given a list of code lengths and a maximum table size, make a set of
+            // tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
+            // if the given code set is incomplete (the tables are still built in this
+            // case), Z_DATA_ERROR if the input is invalid (an over-subscribed set of
+            // lengths), or Z_MEM_ERROR if not enough memory.
+
+            int a; // counter for codes of length k
+            int f; // i repeats in table every f entries
+            int g; // maximum code length
+            int h; // table level
+            int i; // counter, current code
+            int j; // counter
+            int k; // number of bits in current code
+            int l; // bits per table (returned in m)
+            int mask; // (1 << w) - 1, to avoid cc -O bug on HP
+            int p; // pointer into c[], b[], or v[]
+            int q; // points to current table
+            int w; // bits before this table == (l * h)
+            int xp; // pointer into x
+            int y; // number of dummy codes added
+            int z; // number of entries in current table
+
+            // Generate counts for each bit length
+
+            p = 0; i = n;
+            do
+            {
+                c[b[bindex + p]]++; p++; i--; // assume all entries <= BMAX
+            }
+            while (i != 0);
+
+            if (c[0] == n)
+            {
+                // null input--all zero length codes
+                t[0] = -1;
+                m[0] = 0;
+                return Z_OK;
+            }
+
+            // Find minimum and maximum length, bound *m by those
+            l = m[0];
+            for (j = 1; j <= BMAX; j++)
+                if (c[j] != 0)
+                    break;
+            k = j; // minimum code length
+            if (l < j)
+            {
+                l = j;
+            }
+            for (i = BMAX; i != 0; i--)
+            {
+                if (c[i] != 0)
+                    break;
+            }
+            g = i; // maximum code length
+            if (l > i)
+            {
+                l = i;
+            }
+            m[0] = l;
+
+            // Adjust last length count to fill out codes, if needed
+            for (y = 1 << j; j < i; j++, y <<= 1)
+            {
+                if ((y -= c[j]) < 0)
+                {
+                    return Z_DATA_ERROR;
+                }
+            }
+            if ((y -= c[i]) < 0)
+            {
+                return Z_DATA_ERROR;
+            }
+            c[i] += y;
+
+            // Generate starting offsets into the value table for each length
+            x[1] = j = 0;
+            p = 1; xp = 2;
+            while (--i != 0)
+            {
+                // note that i == g from above
+                x[xp] = (j += c[p]);
+                xp++;
+                p++;
+            }
+
+            // Make a table of values in order of bit lengths
+            i = 0; p = 0;
+            do
+            {
+                if ((j = b[bindex + p]) != 0)
+                {
+                    v[x[j]++] = i;
+                }
+                p++;
+            }
+            while (++i < n);
+            n = x[g]; // set n to length of v
+
+            // Generate the Huffman codes and for each, make the table entries
+            x[0] = i = 0; // first Huffman code is zero
+            p = 0; // grab values in bit order
+            h = -1; // no tables yet--level -1
+            w = -l; // bits decoded == (l * h)
+            u[0] = 0; // just to keep compilers happy
+            q = 0; // ditto
+            z = 0; // ditto
+
+            // go through the bit lengths (k already is bits in shortest code)
+            for (; k <= g; k++)
+            {
+                a = c[k];
+                while (a-- != 0)
+                {
+                    // here i is the Huffman code of length k bits for value *p
+                    // make tables up to required level
+                    while (k > w + l)
+                    {
+                        h++;
+                        w += l; // previous table always l bits
+                        // compute minimum size table less than or equal to l bits
+                        z = g - w;
+                        z = (z > l) ? l : z; // table size upper limit
+                        if ((f = 1 << (j = k - w)) > a + 1)
+                        {
+                            // try a k-w bit table
+                            // too few codes for k-w bit table
+                            f -= (a + 1); // deduct codes from patterns left
+                            xp = k;
+                            if (j < z)
+                            {
+                                while (++j < z)
+                                {
+                                    // try smaller tables up to z bits
+                                    if ((f <<= 1) <= c[++xp])
+                                        break; // enough codes to use up j bits
+                                    f -= c[xp]; // else deduct codes from patterns
+                                }
+                            }
+                        }
+                        z = 1 << j; // table entries for j-bit table
+
+                        // allocate new table
+                        if (hn[0] + z > MANY)
+                        {
+                            // (note: doesn't matter for fixed)
+                            return Z_DATA_ERROR; // overflow of MANY
+                        }
+                        u[h] = q = hn[0]; // DEBUG
+                        hn[0] += z;
+
+                        // connect to last table, if there is one
+                        if (h != 0)
+                        {
+                            x[h] = i; // save pattern for backing up
+                            r[0] = (sbyte)j; // bits in this table
+                            r[1] = (sbyte)l; // bits to dump before this table
+                            j = SharedUtils.URShift(i, (w - l));
+                            r[2] = (int)(q - u[h - 1] - j); // offset to this table
+                            Array.Copy(r, 0, hp, (u[h - 1] + j) * 3, 3); // connect to last table
+                        }
+                        else
+                        {
+                            t[0] = q; // first table is returned result
+                        }
+                    }
+
+                    // set up table entry in r
+                    r[1] = (sbyte)(k - w);
+                    if (p >= n)
+                    {
+                        r[0] = 128 + 64; // out of values--invalid code
+                    }
+                    else if (v[p] < s)
+                    {
+                        r[0] = (sbyte)(v[p] < 256 ? 0 : 32 + 64); // 256 is end-of-block
+                        r[2] = v[p++]; // simple code is just the value
+                    }
+                    else
+                    {
+                        r[0] = (sbyte)(e[v[p] - s] + 16 + 64); // non-simple--look up in lists
+                        r[2] = d[v[p++] - s];
+                    }
+
+                    // fill code-like entries with r
+                    f = 1 << (k - w);
+                    for (j = SharedUtils.URShift(i, w); j < z; j += f)
+                    {
+                        Array.Copy(r, 0, hp, (q + j) * 3, 3);
+                    }
+
+                    // backwards increment the k-bit code i
+                    for (j = 1 << (k - 1); (i & j) != 0; j = SharedUtils.URShift(j, 1))
+                    {
+                        i ^= j;
+                    }
+                    i ^= j;
+
+                    // backup over finished tables
+                    mask = (1 << w) - 1; // needed on HP, cc -O bug
+                    while ((i & mask) != x[h])
+                    {
+                        h--; // don't need to update q
+                        w -= l;
+                        mask = (1 << w) - 1;
+                    }
+                }
+            }
+            // Return Z_BUF_ERROR if we were given an incomplete table
+            return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
+        }
+
+        internal int inflate_trees_bits(int[] c, int[] bb, int[] tb, int[] hp, ZlibCodec z)
+        {
+            int result;
+            initWorkArea(19);
+            hn[0] = 0;
+            result = huft_build(c, 0, 19, 19, null, null, tb, bb, hp, hn, v);
+
+            if (result == Z_DATA_ERROR)
+            {
+                z.Message = "oversubscribed dynamic bit lengths tree";
+            }
+            else if (result == Z_BUF_ERROR || bb[0] == 0)
+            {
+                z.Message = "incomplete dynamic bit lengths tree";
+                result = Z_DATA_ERROR;
+            }
+            return result;
+        }
+
+        internal int inflate_trees_dynamic(int nl, int nd, int[] c, int[] bl, int[] bd, int[] tl, int[] td, int[] hp, ZlibCodec z)
+        {
+            int result;
+
+            // build literal/length tree
+            initWorkArea(288);
+            hn[0] = 0;
+            result = huft_build(c, 0, nl, 257, cplens, cplext, tl, bl, hp, hn, v);
+            if (result != Z_OK || bl[0] == 0)
+            {
+                if (result == Z_DATA_ERROR)
+                {
+                    z.Message = "oversubscribed literal/length tree";
+                }
+                else if (result != Z_MEM_ERROR)
+                {
+                    z.Message = "incomplete literal/length tree";
+                    result = Z_DATA_ERROR;
+                }
+                return result;
+            }
+
+            // build distance tree
+            initWorkArea(288);
+            result = huft_build(c, nl, nd, 0, cpdist, cpdext, td, bd, hp, hn, v);
+
+            if (result != Z_OK || (bd[0] == 0 && nl > 257))
+            {
+                if (result == Z_DATA_ERROR)
+                {
+                    z.Message = "oversubscribed distance tree";
+                }
+                else if (result == Z_BUF_ERROR)
+                {
+                    z.Message = "incomplete distance tree";
+                    result = Z_DATA_ERROR;
+                }
+                else if (result != Z_MEM_ERROR)
+                {
+                    z.Message = "empty distance tree with lengths";
+                    result = Z_DATA_ERROR;
+                }
+                return result;
+            }
+
+            return Z_OK;
+        }
+
+        internal static int inflate_trees_fixed(int[] bl, int[] bd, int[][] tl, int[][] td, ZlibCodec z)
+        {
+            bl[0] = fixed_bl;
+            bd[0] = fixed_bd;
+            tl[0] = fixed_tl;
+            td[0] = fixed_td;
+            return Z_OK;
+        }
+
+        private void initWorkArea(int vsize)
+        {
+            if (hn == null)
+            {
+                hn = new int[1];
+                v = new int[vsize];
+                c = new int[BMAX + 1];
+                r = new int[3];
+                u = new int[BMAX];
+                x = new int[BMAX + 1];
+            }
+            else
+            {
+                if (v.Length < vsize)
+                {
+                    v = new int[vsize];
+                }
+                Array.Clear(v, 0, vsize);
+                Array.Clear(c, 0, BMAX + 1);
+                r[0] = 0; r[1] = 0; r[2] = 0;
+                //  for(int i=0; i<BMAX; i++){u[i]=0;}
+                //Array.Copy(c, 0, u, 0, BMAX);
+                Array.Clear(u, 0, BMAX);
+                //  for(int i=0; i<BMAX+1; i++){x[i]=0;}
+                //Array.Copy(c, 0, x, 0, BMAX + 1);
+                Array.Clear(x, 0, BMAX + 1);
+            }
+        }
+    }
+
+    sealed class InflateBlocks
+    {
+        private const int MANY = 1440;
+
+        // Table for deflate from PKZIP's appnote.txt.
+        internal static readonly int[] border = new int[] { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
+
+        private enum InflateBlockMode
+        {
+            TYPE = 0,                     // get type bits (3, including end bit)
+            LENS = 1,                     // get lengths for stored
+            STORED = 2,                     // processing stored block
+            TABLE = 3,                     // get table lengths
+            BTREE = 4,                     // get bit lengths tree for a dynamic block
+            DTREE = 5,                     // get length, distance trees for a dynamic block
+            CODES = 6,                     // processing fixed or dynamic block
+            DRY = 7,                     // output remaining window bytes
+            DONE = 8,                     // finished last block, done
+            BAD = 9,                     // ot a data error--stuck here
+        }
+
+        private InflateBlockMode mode;                    // current inflate_block mode
+
+        internal int left;                                // if STORED, bytes left to copy
+
+        internal int table;                               // table lengths (14 bits)
+        internal int index;                               // index into blens (or border)
+        internal int[] blens;                             // bit lengths of codes
+        internal int[] bb = new int[1];                   // bit length tree depth
+        internal int[] tb = new int[1];                   // bit length decoding tree
+
+        internal InflateCodes codes = new InflateCodes(); // if CODES, current state
+
+        internal int last;                                // true if this block is the last block
+
+        internal ZlibCodec _codec;                        // pointer back to this zlib stream
+
+        // mode independent information
+        internal int bitk;                                // bits in bit buffer
+        internal int bitb;                                // bit buffer
+        internal int[] hufts;                             // single malloc for tree space
+        internal byte[] window;                           // sliding window
+        internal int end;                                 // one byte after sliding window
+        internal int readAt;                              // window read pointer
+        internal int writeAt;                             // window write pointer
+        internal System.Object checkfn;                   // check function
+        internal uint check;                              // check on output
+
+        internal InfTree inftree = new InfTree();
+
+        internal InflateBlocks(ZlibCodec codec, System.Object checkfn, int w)
+        {
+            _codec = codec;
+            hufts = new int[MANY * 3];
+            window = new byte[w];
+            end = w;
+            this.checkfn = checkfn;
+            mode = InflateBlockMode.TYPE;
+            Reset();
+        }
+
+        internal uint Reset()
+        {
+            uint oldCheck = check;
+            mode = InflateBlockMode.TYPE;
+            bitk = 0;
+            bitb = 0;
+            readAt = writeAt = 0;
+
+            if (checkfn != null)
+                _codec._Adler32 = check = Adler.Adler32(0, null, 0, 0);
+            return oldCheck;
+        }
+
+
+        internal int Process(int r)
+        {
+            int t; // temporary storage
+            int b; // bit buffer
+            int k; // bits in bit buffer
+            int p; // input data pointer
+            int n; // bytes available there
+            int q; // output window write pointer
+            int m; // bytes to end of window or read pointer
+
+            // copy input/output information to locals (UPDATE macro restores)
+
+            p = _codec.NextIn;
+            n = _codec.AvailableBytesIn;
+            b = bitb;
+            k = bitk;
+
+            q = writeAt;
+            m = (int)(q < readAt ? readAt - q - 1 : end - q);
+
+
+            // process input based on current state
+            while (true)
+            {
+                switch (mode)
+                {
+                    case InflateBlockMode.TYPE:
+
+                        while (k < (3))
+                        {
+                            if (n != 0)
+                            {
+                                r = ZlibConstants.Z_OK;
+                            }
+                            else
+                            {
+                                bitb = b; bitk = k;
+                                _codec.AvailableBytesIn = n;
+                                _codec.TotalBytesIn += p - _codec.NextIn;
+                                _codec.NextIn = p;
+                                writeAt = q;
+                                return Flush(r);
+                            }
+
+                            n--;
+                            b |= (_codec.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+                        t = (int)(b & 7);
+                        last = t & 1;
+
+                        switch ((uint)t >> 1)
+                        {
+                            case 0:  // stored
+                                b >>= 3; k -= (3);
+                                t = k & 7; // go to byte boundary
+                                b >>= t; k -= t;
+                                mode = InflateBlockMode.LENS; // get length of stored block
+                                break;
+
+                            case 1:  // fixed
+                                int[] bl = new int[1];
+                                int[] bd = new int[1];
+                                int[][] tl = new int[1][];
+                                int[][] td = new int[1][];
+                                InfTree.inflate_trees_fixed(bl, bd, tl, td, _codec);
+                                codes.Init(bl[0], bd[0], tl[0], 0, td[0], 0);
+                                b >>= 3; k -= 3;
+                                mode = InflateBlockMode.CODES;
+                                break;
+
+                            case 2:  // dynamic
+                                b >>= 3; k -= 3;
+                                mode = InflateBlockMode.TABLE;
+                                break;
+
+                            case 3:  // illegal
+                                b >>= 3; k -= 3;
+                                mode = InflateBlockMode.BAD;
+                                _codec.Message = "invalid block type";
+                                r = ZlibConstants.Z_DATA_ERROR;
+                                bitb = b; bitk = k;
+                                _codec.AvailableBytesIn = n;
+                                _codec.TotalBytesIn += p - _codec.NextIn;
+                                _codec.NextIn = p;
+                                writeAt = q;
+                                return Flush(r);
+                        }
+                        break;
+
+                    case InflateBlockMode.LENS:
+
+                        while (k < (32))
+                        {
+                            if (n != 0)
+                            {
+                                r = ZlibConstants.Z_OK;
+                            }
+                            else
+                            {
+                                bitb = b; bitk = k;
+                                _codec.AvailableBytesIn = n;
+                                _codec.TotalBytesIn += p - _codec.NextIn;
+                                _codec.NextIn = p;
+                                writeAt = q;
+                                return Flush(r);
+                            }
+                            ;
+                            n--;
+                            b |= (_codec.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+
+                        if ((((~b) >> 16) & 0xffff) != (b & 0xffff))
+                        {
+                            mode = InflateBlockMode.BAD;
+                            _codec.Message = "invalid stored block lengths";
+                            r = ZlibConstants.Z_DATA_ERROR;
+
+                            bitb = b; bitk = k;
+                            _codec.AvailableBytesIn = n;
+                            _codec.TotalBytesIn += p - _codec.NextIn;
+                            _codec.NextIn = p;
+                            writeAt = q;
+                            return Flush(r);
+                        }
+                        left = (b & 0xffff);
+                        b = k = 0; // dump bits
+                        mode = left != 0 ? InflateBlockMode.STORED : (last != 0 ? InflateBlockMode.DRY : InflateBlockMode.TYPE);
+                        break;
+
+                    case InflateBlockMode.STORED:
+                        if (n == 0)
+                        {
+                            bitb = b; bitk = k;
+                            _codec.AvailableBytesIn = n;
+                            _codec.TotalBytesIn += p - _codec.NextIn;
+                            _codec.NextIn = p;
+                            writeAt = q;
+                            return Flush(r);
+                        }
+
+                        if (m == 0)
+                        {
+                            if (q == end && readAt != 0)
+                            {
+                                q = 0; m = (int)(q < readAt ? readAt - q - 1 : end - q);
+                            }
+                            if (m == 0)
+                            {
+                                writeAt = q;
+                                r = Flush(r);
+                                q = writeAt; m = (int)(q < readAt ? readAt - q - 1 : end - q);
+                                if (q == end && readAt != 0)
+                                {
+                                    q = 0; m = (int)(q < readAt ? readAt - q - 1 : end - q);
+                                }
+                                if (m == 0)
+                                {
+                                    bitb = b; bitk = k;
+                                    _codec.AvailableBytesIn = n;
+                                    _codec.TotalBytesIn += p - _codec.NextIn;
+                                    _codec.NextIn = p;
+                                    writeAt = q;
+                                    return Flush(r);
+                                }
+                            }
+                        }
+                        r = ZlibConstants.Z_OK;
+
+                        t = left;
+                        if (t > n)
+                            t = n;
+                        if (t > m)
+                            t = m;
+                        Array.Copy(_codec.InputBuffer, p, window, q, t);
+                        p += t; n -= t;
+                        q += t; m -= t;
+                        if ((left -= t) != 0)
+                            break;
+                        mode = last != 0 ? InflateBlockMode.DRY : InflateBlockMode.TYPE;
+                        break;
+
+                    case InflateBlockMode.TABLE:
+
+                        while (k < (14))
+                        {
+                            if (n != 0)
+                            {
+                                r = ZlibConstants.Z_OK;
+                            }
+                            else
+                            {
+                                bitb = b; bitk = k;
+                                _codec.AvailableBytesIn = n;
+                                _codec.TotalBytesIn += p - _codec.NextIn;
+                                _codec.NextIn = p;
+                                writeAt = q;
+                                return Flush(r);
+                            }
+
+                            n--;
+                            b |= (_codec.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+
+                        table = t = (b & 0x3fff);
+                        if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
+                        {
+                            mode = InflateBlockMode.BAD;
+                            _codec.Message = "too many length or distance symbols";
+                            r = ZlibConstants.Z_DATA_ERROR;
+
+                            bitb = b; bitk = k;
+                            _codec.AvailableBytesIn = n;
+                            _codec.TotalBytesIn += p - _codec.NextIn;
+                            _codec.NextIn = p;
+                            writeAt = q;
+                            return Flush(r);
+                        }
+                        t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
+                        if (blens == null || blens.Length < t)
+                        {
+                            blens = new int[t];
+                        }
+                        else
+                        {
+                            Array.Clear(blens, 0, t);
+                            // for (int i = 0; i < t; i++)
+                            // {
+                            //     blens[i] = 0;
+                            // }
+                        }
+
+                        b >>= 14;
+                        k -= 14;
+
+
+                        index = 0;
+                        mode = InflateBlockMode.BTREE;
+                        goto case InflateBlockMode.BTREE;
+
+                    case InflateBlockMode.BTREE:
+                        while (index < 4 + (table >> 10))
+                        {
+                            while (k < (3))
+                            {
+                                if (n != 0)
+                                {
+                                    r = ZlibConstants.Z_OK;
+                                }
+                                else
+                                {
+                                    bitb = b; bitk = k;
+                                    _codec.AvailableBytesIn = n;
+                                    _codec.TotalBytesIn += p - _codec.NextIn;
+                                    _codec.NextIn = p;
+                                    writeAt = q;
+                                    return Flush(r);
+                                }
+
+                                n--;
+                                b |= (_codec.InputBuffer[p++] & 0xff) << k;
+                                k += 8;
+                            }
+
+                            blens[border[index++]] = b & 7;
+
+                            b >>= 3; k -= 3;
+                        }
+
+                        while (index < 19)
+                        {
+                            blens[border[index++]] = 0;
+                        }
+
+                        bb[0] = 7;
+                        t = inftree.inflate_trees_bits(blens, bb, tb, hufts, _codec);
+                        if (t != ZlibConstants.Z_OK)
+                        {
+                            r = t;
+                            if (r == ZlibConstants.Z_DATA_ERROR)
+                            {
+                                blens = null;
+                                mode = InflateBlockMode.BAD;
+                            }
+
+                            bitb = b; bitk = k;
+                            _codec.AvailableBytesIn = n;
+                            _codec.TotalBytesIn += p - _codec.NextIn;
+                            _codec.NextIn = p;
+                            writeAt = q;
+                            return Flush(r);
+                        }
+
+                        index = 0;
+                        mode = InflateBlockMode.DTREE;
+                        goto case InflateBlockMode.DTREE;
+
+                    case InflateBlockMode.DTREE:
+                        while (true)
+                        {
+                            t = table;
+                            if (!(index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f)))
+                            {
+                                break;
+                            }
+
+                            int i, j, c;
+
+                            t = bb[0];
+
+                            while (k < t)
+                            {
+                                if (n != 0)
+                                {
+                                    r = ZlibConstants.Z_OK;
+                                }
+                                else
+                                {
+                                    bitb = b; bitk = k;
+                                    _codec.AvailableBytesIn = n;
+                                    _codec.TotalBytesIn += p - _codec.NextIn;
+                                    _codec.NextIn = p;
+                                    writeAt = q;
+                                    return Flush(r);
+                                }
+
+                                n--;
+                                b |= (_codec.InputBuffer[p++] & 0xff) << k;
+                                k += 8;
+                            }
+
+                            t = hufts[(tb[0] + (b & InternalInflateConstants.InflateMask[t])) * 3 + 1];
+                            c = hufts[(tb[0] + (b & InternalInflateConstants.InflateMask[t])) * 3 + 2];
+
+                            if (c < 16)
+                            {
+                                b >>= t; k -= t;
+                                blens[index++] = c;
+                            }
+                            else
+                            {
+                                // c == 16..18
+                                i = c == 18 ? 7 : c - 14;
+                                j = c == 18 ? 11 : 3;
+
+                                while (k < (t + i))
+                                {
+                                    if (n != 0)
+                                    {
+                                        r = ZlibConstants.Z_OK;
+                                    }
+                                    else
+                                    {
+                                        bitb = b; bitk = k;
+                                        _codec.AvailableBytesIn = n;
+                                        _codec.TotalBytesIn += p - _codec.NextIn;
+                                        _codec.NextIn = p;
+                                        writeAt = q;
+                                        return Flush(r);
+                                    }
+
+                                    n--;
+                                    b |= (_codec.InputBuffer[p++] & 0xff) << k;
+                                    k += 8;
+                                }
+
+                                b >>= t; k -= t;
+
+                                j += (b & InternalInflateConstants.InflateMask[i]);
+
+                                b >>= i; k -= i;
+
+                                i = index;
+                                t = table;
+                                if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) || (c == 16 && i < 1))
+                                {
+                                    blens = null;
+                                    mode = InflateBlockMode.BAD;
+                                    _codec.Message = "invalid bit length repeat";
+                                    r = ZlibConstants.Z_DATA_ERROR;
+
+                                    bitb = b; bitk = k;
+                                    _codec.AvailableBytesIn = n;
+                                    _codec.TotalBytesIn += p - _codec.NextIn;
+                                    _codec.NextIn = p;
+                                    writeAt = q;
+                                    return Flush(r);
+                                }
+
+                                c = (c == 16) ? blens[i - 1] : 0;
+                                do
+                                {
+                                    blens[i++] = c;
+                                }
+                                while (--j != 0);
+                                index = i;
+                            }
+                        }
+
+                        tb[0] = -1;
+                        {
+                            int[] bl = new int[] { 9 };  // must be <= 9 for lookahead assumptions
+                            int[] bd = new int[] { 6 }; // must be <= 9 for lookahead assumptions
+                            int[] tl = new int[1];
+                            int[] td = new int[1];
+
+                            t = table;
+                            t = inftree.inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), blens, bl, bd, tl, td, hufts, _codec);
+
+                            if (t != ZlibConstants.Z_OK)
+                            {
+                                if (t == ZlibConstants.Z_DATA_ERROR)
+                                {
+                                    blens = null;
+                                    mode = InflateBlockMode.BAD;
+                                }
+                                r = t;
+
+                                bitb = b; bitk = k;
+                                _codec.AvailableBytesIn = n;
+                                _codec.TotalBytesIn += p - _codec.NextIn;
+                                _codec.NextIn = p;
+                                writeAt = q;
+                                return Flush(r);
+                            }
+                            codes.Init(bl[0], bd[0], hufts, tl[0], hufts, td[0]);
+                        }
+                        mode = InflateBlockMode.CODES;
+                        goto case InflateBlockMode.CODES;
+
+                    case InflateBlockMode.CODES:
+                        bitb = b; bitk = k;
+                        _codec.AvailableBytesIn = n;
+                        _codec.TotalBytesIn += p - _codec.NextIn;
+                        _codec.NextIn = p;
+                        writeAt = q;
+
+                        r = codes.Process(this, r);
+                        if (r != ZlibConstants.Z_STREAM_END)
+                        {
+                            return Flush(r);
+                        }
+
+                        r = ZlibConstants.Z_OK;
+                        p = _codec.NextIn;
+                        n = _codec.AvailableBytesIn;
+                        b = bitb;
+                        k = bitk;
+                        q = writeAt;
+                        m = (int)(q < readAt ? readAt - q - 1 : end - q);
+
+                        if (last == 0)
+                        {
+                            mode = InflateBlockMode.TYPE;
+                            break;
+                        }
+                        mode = InflateBlockMode.DRY;
+                        goto case InflateBlockMode.DRY;
+
+                    case InflateBlockMode.DRY:
+                        writeAt = q;
+                        r = Flush(r);
+                        q = writeAt; m = (int)(q < readAt ? readAt - q - 1 : end - q);
+                        if (readAt != writeAt)
+                        {
+                            bitb = b; bitk = k;
+                            _codec.AvailableBytesIn = n;
+                            _codec.TotalBytesIn += p - _codec.NextIn;
+                            _codec.NextIn = p;
+                            writeAt = q;
+                            return Flush(r);
+                        }
+                        mode = InflateBlockMode.DONE;
+                        goto case InflateBlockMode.DONE;
+
+                    case InflateBlockMode.DONE:
+                        r = ZlibConstants.Z_STREAM_END;
+                        bitb = b;
+                        bitk = k;
+                        _codec.AvailableBytesIn = n;
+                        _codec.TotalBytesIn += p - _codec.NextIn;
+                        _codec.NextIn = p;
+                        writeAt = q;
+                        return Flush(r);
+
+                    case InflateBlockMode.BAD:
+                        r = ZlibConstants.Z_DATA_ERROR;
+
+                        bitb = b; bitk = k;
+                        _codec.AvailableBytesIn = n;
+                        _codec.TotalBytesIn += p - _codec.NextIn;
+                        _codec.NextIn = p;
+                        writeAt = q;
+                        return Flush(r);
+
+
+                    default:
+                        r = ZlibConstants.Z_STREAM_ERROR;
+
+                        bitb = b; bitk = k;
+                        _codec.AvailableBytesIn = n;
+                        _codec.TotalBytesIn += p - _codec.NextIn;
+                        _codec.NextIn = p;
+                        writeAt = q;
+                        return Flush(r);
+                }
+            }
+        }
+
+
+        internal void Free()
+        {
+            Reset();
+            window = null;
+            hufts = null;
+        }
+
+        internal void SetDictionary(byte[] d, int start, int n)
+        {
+            Array.Copy(d, start, window, 0, n);
+            readAt = writeAt = n;
+        }
+
+        // Returns true if inflate is currently at the end of a block generated
+        // by Z_SYNC_FLUSH or Z_FULL_FLUSH.
+        internal int SyncPoint()
+        {
+            return mode == InflateBlockMode.LENS ? 1 : 0;
+        }
+
+        // copy as much as possible from the sliding window to the output area
+        internal int Flush(int r)
+        {
+            int nBytes;
+
+            for (int pass = 0; pass < 2; pass++)
+            {
+                if (pass == 0)
+                {
+                    // compute number of bytes to copy as far as end of window
+                    nBytes = (int)((readAt <= writeAt ? writeAt : end) - readAt);
+                }
+                else
+                {
+                    // compute bytes to copy
+                    nBytes = writeAt - readAt;
+                }
+
+                // workitem 8870
+                if (nBytes == 0)
+                {
+                    if (r == ZlibConstants.Z_BUF_ERROR)
+                        r = ZlibConstants.Z_OK;
+                    return r;
+                }
+
+                if (nBytes > _codec.AvailableBytesOut)
+                    nBytes = _codec.AvailableBytesOut;
+
+                if (nBytes != 0 && r == ZlibConstants.Z_BUF_ERROR)
+                    r = ZlibConstants.Z_OK;
+
+                // update counters
+                _codec.AvailableBytesOut -= nBytes;
+                _codec.TotalBytesOut += nBytes;
+
+                // update check information
+                if (checkfn != null)
+                    _codec._Adler32 = check = Adler.Adler32(check, window, readAt, nBytes);
+
+                // copy as far as end of window
+                Array.Copy(window, readAt, _codec.OutputBuffer, _codec.NextOut, nBytes);
+                _codec.NextOut += nBytes;
+                readAt += nBytes;
+
+                // see if more to copy at beginning of window
+                if (readAt == end && pass == 0)
+                {
+                    // wrap pointers
+                    readAt = 0;
+                    if (writeAt == end)
+                        writeAt = 0;
+                }
+                else pass++;
+            }
+
+            // done
+            return r;
+        }
+    }
+
+
+    internal static class InternalInflateConstants
+    {
+        // And'ing with mask[n] masks the lower n bits
+        internal static readonly int[] InflateMask = new int[] {
+            0x00000000, 0x00000001, 0x00000003, 0x00000007,
+            0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,
+            0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,
+            0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff };
+    }
+
+
+    sealed class InflateCodes
+    {
+        // waiting for "i:"=input,
+        //             "o:"=output,
+        //             "x:"=nothing
+        private const int START = 0; // x: set up for LEN
+        private const int LEN = 1; // i: get length/literal/eob next
+        private const int LENEXT = 2; // i: getting length extra (have base)
+        private const int DIST = 3; // i: get distance next
+        private const int DISTEXT = 4; // i: getting distance extra
+        private const int COPY = 5; // o: copying bytes in window, waiting for space
+        private const int LIT = 6; // o: got literal, waiting for output space
+        private const int WASH = 7; // o: got eob, possibly still output waiting
+        private const int END = 8; // x: got eob and all data flushed
+        private const int BADCODE = 9; // x: got error
+
+        internal int mode;        // current inflate_codes mode
+
+        // mode dependent information
+        internal int len;
+
+        internal int[] tree;      // pointer into tree
+        internal int tree_index = 0;
+        internal int need;        // bits needed
+
+        internal int lit;
+
+        // if EXT or COPY, where and how much
+        internal int bitsToGet;   // bits to get for extra
+        internal int dist;        // distance back to copy from
+
+        internal byte lbits;      // ltree bits decoded per branch
+        internal byte dbits;      // dtree bits decoder per branch
+        internal int[] ltree;     // literal/length/eob tree
+        internal int ltree_index; // literal/length/eob tree
+        internal int[] dtree;     // distance tree
+        internal int dtree_index; // distance tree
+
+        internal InflateCodes()
+        {
+        }
+
+        internal void Init(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index)
+        {
+            mode = START;
+            lbits = (byte)bl;
+            dbits = (byte)bd;
+            ltree = tl;
+            ltree_index = tl_index;
+            dtree = td;
+            dtree_index = td_index;
+            tree = null;
+        }
+
+        internal int Process(InflateBlocks blocks, int r)
+        {
+            int j;      // temporary storage
+            int tindex; // temporary pointer
+            int e;      // extra bits or operation
+            int b = 0;  // bit buffer
+            int k = 0;  // bits in bit buffer
+            int p = 0;  // input data pointer
+            int n;      // bytes available there
+            int q;      // output window write pointer
+            int m;      // bytes to end of window or read pointer
+            int f;      // pointer to copy strings from
+
+            ZlibCodec z = blocks._codec;
+
+            // copy input/output information to locals (UPDATE macro restores)
+            p = z.NextIn;
+            n = z.AvailableBytesIn;
+            b = blocks.bitb;
+            k = blocks.bitk;
+            q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+
+            // process input and output based on current state
+            while (true)
+            {
+                switch (mode)
+                {
+                    // waiting for "i:"=input, "o:"=output, "x:"=nothing
+                    case START:  // x: set up for LEN
+                        if (m >= 258 && n >= 10)
+                        {
+                            blocks.bitb = b; blocks.bitk = k;
+                            z.AvailableBytesIn = n;
+                            z.TotalBytesIn += p - z.NextIn;
+                            z.NextIn = p;
+                            blocks.writeAt = q;
+                            r = InflateFast(lbits, dbits, ltree, ltree_index, dtree, dtree_index, blocks, z);
+
+                            p = z.NextIn;
+                            n = z.AvailableBytesIn;
+                            b = blocks.bitb;
+                            k = blocks.bitk;
+                            q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+
+                            if (r != ZlibConstants.Z_OK)
+                            {
+                                mode = (r == ZlibConstants.Z_STREAM_END) ? WASH : BADCODE;
+                                break;
+                            }
+                        }
+                        need = lbits;
+                        tree = ltree;
+                        tree_index = ltree_index;
+
+                        mode = LEN;
+                        goto case LEN;
+
+                    case LEN:  // i: get length/literal/eob next
+                        j = need;
+
+                        while (k < j)
+                        {
+                            if (n != 0)
+                                r = ZlibConstants.Z_OK;
+                            else
+                            {
+                                blocks.bitb = b; blocks.bitk = k;
+                                z.AvailableBytesIn = n;
+                                z.TotalBytesIn += p - z.NextIn;
+                                z.NextIn = p;
+                                blocks.writeAt = q;
+                                return blocks.Flush(r);
+                            }
+                            n--;
+                            b |= (z.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+
+                        tindex = (tree_index + (b & InternalInflateConstants.InflateMask[j])) * 3;
+
+                        b >>= (tree[tindex + 1]);
+                        k -= (tree[tindex + 1]);
+
+                        e = tree[tindex];
+
+                        if (e == 0)
+                        {
+                            // literal
+                            lit = tree[tindex + 2];
+                            mode = LIT;
+                            break;
+                        }
+                        if ((e & 16) != 0)
+                        {
+                            // length
+                            bitsToGet = e & 15;
+                            len = tree[tindex + 2];
+                            mode = LENEXT;
+                            break;
+                        }
+                        if ((e & 64) == 0)
+                        {
+                            // next table
+                            need = e;
+                            tree_index = tindex / 3 + tree[tindex + 2];
+                            break;
+                        }
+                        if ((e & 32) != 0)
+                        {
+                            // end of block
+                            mode = WASH;
+                            break;
+                        }
+                        mode = BADCODE; // invalid code
+                        z.Message = "invalid literal/length code";
+                        r = ZlibConstants.Z_DATA_ERROR;
+
+                        blocks.bitb = b; blocks.bitk = k;
+                        z.AvailableBytesIn = n;
+                        z.TotalBytesIn += p - z.NextIn;
+                        z.NextIn = p;
+                        blocks.writeAt = q;
+                        return blocks.Flush(r);
+
+
+                    case LENEXT:  // i: getting length extra (have base)
+                        j = bitsToGet;
+
+                        while (k < j)
+                        {
+                            if (n != 0)
+                                r = ZlibConstants.Z_OK;
+                            else
+                            {
+                                blocks.bitb = b; blocks.bitk = k;
+                                z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                                blocks.writeAt = q;
+                                return blocks.Flush(r);
+                            }
+                            n--; b |= (z.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+
+                        len += (b & InternalInflateConstants.InflateMask[j]);
+
+                        b >>= j;
+                        k -= j;
+
+                        need = dbits;
+                        tree = dtree;
+                        tree_index = dtree_index;
+                        mode = DIST;
+                        goto case DIST;
+
+                    case DIST:  // i: get distance next
+                        j = need;
+
+                        while (k < j)
+                        {
+                            if (n != 0)
+                                r = ZlibConstants.Z_OK;
+                            else
+                            {
+                                blocks.bitb = b; blocks.bitk = k;
+                                z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                                blocks.writeAt = q;
+                                return blocks.Flush(r);
+                            }
+                            n--; b |= (z.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+
+                        tindex = (tree_index + (b & InternalInflateConstants.InflateMask[j])) * 3;
+
+                        b >>= tree[tindex + 1];
+                        k -= tree[tindex + 1];
+
+                        e = (tree[tindex]);
+                        if ((e & 0x10) != 0)
+                        {
+                            // distance
+                            bitsToGet = e & 15;
+                            dist = tree[tindex + 2];
+                            mode = DISTEXT;
+                            break;
+                        }
+                        if ((e & 64) == 0)
+                        {
+                            // next table
+                            need = e;
+                            tree_index = tindex / 3 + tree[tindex + 2];
+                            break;
+                        }
+                        mode = BADCODE; // invalid code
+                        z.Message = "invalid distance code";
+                        r = ZlibConstants.Z_DATA_ERROR;
+
+                        blocks.bitb = b; blocks.bitk = k;
+                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                        blocks.writeAt = q;
+                        return blocks.Flush(r);
+
+
+                    case DISTEXT:  // i: getting distance extra
+                        j = bitsToGet;
+
+                        while (k < j)
+                        {
+                            if (n != 0)
+                                r = ZlibConstants.Z_OK;
+                            else
+                            {
+                                blocks.bitb = b; blocks.bitk = k;
+                                z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                                blocks.writeAt = q;
+                                return blocks.Flush(r);
+                            }
+                            n--; b |= (z.InputBuffer[p++] & 0xff) << k;
+                            k += 8;
+                        }
+
+                        dist += (b & InternalInflateConstants.InflateMask[j]);
+
+                        b >>= j;
+                        k -= j;
+
+                        mode = COPY;
+                        goto case COPY;
+
+                    case COPY:  // o: copying bytes in window, waiting for space
+                        f = q - dist;
+                        while (f < 0)
+                        {
+                            // modulo window size-"while" instead
+                            f += blocks.end; // of "if" handles invalid distances
+                        }
+                        while (len != 0)
+                        {
+                            if (m == 0)
+                            {
+                                if (q == blocks.end && blocks.readAt != 0)
+                                {
+                                    q = 0; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+                                }
+                                if (m == 0)
+                                {
+                                    blocks.writeAt = q; r = blocks.Flush(r);
+                                    q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+
+                                    if (q == blocks.end && blocks.readAt != 0)
+                                    {
+                                        q = 0; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+                                    }
+
+                                    if (m == 0)
+                                    {
+                                        blocks.bitb = b; blocks.bitk = k;
+                                        z.AvailableBytesIn = n;
+                                        z.TotalBytesIn += p - z.NextIn;
+                                        z.NextIn = p;
+                                        blocks.writeAt = q;
+                                        return blocks.Flush(r);
+                                    }
+                                }
+                            }
+
+                            blocks.window[q++] = blocks.window[f++]; m--;
+
+                            if (f == blocks.end)
+                                f = 0;
+                            len--;
+                        }
+                        mode = START;
+                        break;
+
+                    case LIT:  // o: got literal, waiting for output space
+                        if (m == 0)
+                        {
+                            if (q == blocks.end && blocks.readAt != 0)
+                            {
+                                q = 0; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+                            }
+                            if (m == 0)
+                            {
+                                blocks.writeAt = q; r = blocks.Flush(r);
+                                q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+
+                                if (q == blocks.end && blocks.readAt != 0)
+                                {
+                                    q = 0; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+                                }
+                                if (m == 0)
+                                {
+                                    blocks.bitb = b; blocks.bitk = k;
+                                    z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                                    blocks.writeAt = q;
+                                    return blocks.Flush(r);
+                                }
+                            }
+                        }
+                        r = ZlibConstants.Z_OK;
+
+                        blocks.window[q++] = (byte)lit; m--;
+
+                        mode = START;
+                        break;
+
+                    case WASH:  // o: got eob, possibly more output
+                        if (k > 7)
+                        {
+                            // return unused byte, if any
+                            k -= 8;
+                            n++;
+                            p--; // can always return one
+                        }
+
+                        blocks.writeAt = q; r = blocks.Flush(r);
+                        q = blocks.writeAt; m = q < blocks.readAt ? blocks.readAt - q - 1 : blocks.end - q;
+
+                        if (blocks.readAt != blocks.writeAt)
+                        {
+                            blocks.bitb = b; blocks.bitk = k;
+                            z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                            blocks.writeAt = q;
+                            return blocks.Flush(r);
+                        }
+                        mode = END;
+                        goto case END;
+
+                    case END:
+                        r = ZlibConstants.Z_STREAM_END;
+                        blocks.bitb = b; blocks.bitk = k;
+                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                        blocks.writeAt = q;
+                        return blocks.Flush(r);
+
+                    case BADCODE:  // x: got error
+
+                        r = ZlibConstants.Z_DATA_ERROR;
+
+                        blocks.bitb = b; blocks.bitk = k;
+                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                        blocks.writeAt = q;
+                        return blocks.Flush(r);
+
+                    default:
+                        r = ZlibConstants.Z_STREAM_ERROR;
+
+                        blocks.bitb = b; blocks.bitk = k;
+                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                        blocks.writeAt = q;
+                        return blocks.Flush(r);
+                }
+            }
+        }
+
+
+        // Called with number of bytes left to write in window at least 258
+        // (the maximum string length) and number of input bytes available
+        // at least ten.  The ten bytes are six bytes for the longest length/
+        // distance pair plus four bytes for overloading the bit buffer.
+
+        internal int InflateFast(int bl, int bd, int[] tl, int tl_index, int[] td, int td_index, InflateBlocks s, ZlibCodec z)
+        {
+            int t;        // temporary pointer
+            int[] tp;     // temporary pointer
+            int tp_index; // temporary pointer
+            int e;        // extra bits or operation
+            int b;        // bit buffer
+            int k;        // bits in bit buffer
+            int p;        // input data pointer
+            int n;        // bytes available there
+            int q;        // output window write pointer
+            int m;        // bytes to end of window or read pointer
+            int ml;       // mask for literal/length tree
+            int md;       // mask for distance tree
+            int c;        // bytes to copy
+            int d;        // distance back to copy from
+            int r;        // copy source pointer
+
+            int tp_index_t_3; // (tp_index+t)*3
+
+            // load input, output, bit values
+            p = z.NextIn; n = z.AvailableBytesIn; b = s.bitb; k = s.bitk;
+            q = s.writeAt; m = q < s.readAt ? s.readAt - q - 1 : s.end - q;
+
+            // initialize masks
+            ml = InternalInflateConstants.InflateMask[bl];
+            md = InternalInflateConstants.InflateMask[bd];
+
+            // do until not enough input or output space for fast loop
+            do
+            {
+                // assume called with m >= 258 && n >= 10
+                // get literal/length code
+                while (k < (20))
+                {
+                    // max bits for literal/length code
+                    n--;
+                    b |= (z.InputBuffer[p++] & 0xff) << k; k += 8;
+                }
+
+                t = b & ml;
+                tp = tl;
+                tp_index = tl_index;
+                tp_index_t_3 = (tp_index + t) * 3;
+                if ((e = tp[tp_index_t_3]) == 0)
+                {
+                    b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
+
+                    s.window[q++] = (byte)tp[tp_index_t_3 + 2];
+                    m--;
+                    continue;
+                }
+                do
+                {
+
+                    b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
+
+                    if ((e & 16) != 0)
+                    {
+                        e &= 15;
+                        c = tp[tp_index_t_3 + 2] + ((int)b & InternalInflateConstants.InflateMask[e]);
+
+                        b >>= e; k -= e;
+
+                        // decode distance base of block to copy
+                        while (k < 15)
+                        {
+                            // max bits for distance code
+                            n--;
+                            b |= (z.InputBuffer[p++] & 0xff) << k; k += 8;
+                        }
+
+                        t = b & md;
+                        tp = td;
+                        tp_index = td_index;
+                        tp_index_t_3 = (tp_index + t) * 3;
+                        e = tp[tp_index_t_3];
+
+                        do
+                        {
+
+                            b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
+
+                            if ((e & 16) != 0)
+                            {
+                                // get extra bits to add to distance base
+                                e &= 15;
+                                while (k < e)
+                                {
+                                    // get extra bits (up to 13)
+                                    n--;
+                                    b |= (z.InputBuffer[p++] & 0xff) << k; k += 8;
+                                }
+
+                                d = tp[tp_index_t_3 + 2] + (b & InternalInflateConstants.InflateMask[e]);
+
+                                b >>= e; k -= e;
+
+                                // do the copy
+                                m -= c;
+                                if (q >= d)
+                                {
+                                    // offset before dest
+                                    //  just copy
+                                    r = q - d;
+                                    if (q - r > 0 && 2 > (q - r))
+                                    {
+                                        s.window[q++] = s.window[r++]; // minimum count is three,
+                                        s.window[q++] = s.window[r++]; // so unroll loop a little
+                                        c -= 2;
+                                    }
+                                    else
+                                    {
+                                        Array.Copy(s.window, r, s.window, q, 2);
+                                        q += 2; r += 2; c -= 2;
+                                    }
+                                }
+                                else
+                                {
+                                    // else offset after destination
+                                    r = q - d;
+                                    do
+                                    {
+                                        r += s.end; // force pointer in window
+                                    }
+                                    while (r < 0); // covers invalid distances
+                                    e = s.end - r;
+                                    if (c > e)
+                                    {
+                                        // if source crosses,
+                                        c -= e; // wrapped copy
+                                        if (q - r > 0 && e > (q - r))
+                                        {
+                                            do
+                                            {
+                                                s.window[q++] = s.window[r++];
+                                            }
+                                            while (--e != 0);
+                                        }
+                                        else
+                                        {
+                                            Array.Copy(s.window, r, s.window, q, e);
+                                            q += e; r += e; e = 0;
+                                        }
+                                        r = 0; // copy rest from start of window
+                                    }
+                                }
+
+                                // copy all or what's left
+                                if (q - r > 0 && c > (q - r))
+                                {
+                                    do
+                                    {
+                                        s.window[q++] = s.window[r++];
+                                    }
+                                    while (--c != 0);
+                                }
+                                else
+                                {
+                                    Array.Copy(s.window, r, s.window, q, c);
+                                    q += c; r += c; c = 0;
+                                }
+                                break;
+                            }
+                            else if ((e & 64) == 0)
+                            {
+                                t += tp[tp_index_t_3 + 2];
+                                t += (b & InternalInflateConstants.InflateMask[e]);
+                                tp_index_t_3 = (tp_index + t) * 3;
+                                e = tp[tp_index_t_3];
+                            }
+                            else
+                            {
+                                z.Message = "invalid distance code";
+
+                                c = z.AvailableBytesIn - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= (c << 3);
+
+                                s.bitb = b; s.bitk = k;
+                                z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                                s.writeAt = q;
+
+                                return ZlibConstants.Z_DATA_ERROR;
+                            }
+                        }
+                        while (true);
+                        break;
+                    }
+
+                    if ((e & 64) == 0)
+                    {
+                        t += tp[tp_index_t_3 + 2];
+                        t += (b & InternalInflateConstants.InflateMask[e]);
+                        tp_index_t_3 = (tp_index + t) * 3;
+                        if ((e = tp[tp_index_t_3]) == 0)
+                        {
+                            b >>= (tp[tp_index_t_3 + 1]); k -= (tp[tp_index_t_3 + 1]);
+                            s.window[q++] = (byte)tp[tp_index_t_3 + 2];
+                            m--;
+                            break;
+                        }
+                    }
+                    else if ((e & 32) != 0)
+                    {
+                        c = z.AvailableBytesIn - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= (c << 3);
+
+                        s.bitb = b; s.bitk = k;
+                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                        s.writeAt = q;
+
+                        return ZlibConstants.Z_STREAM_END;
+                    }
+                    else
+                    {
+                        z.Message = "invalid literal/length code";
+
+                        c = z.AvailableBytesIn - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= (c << 3);
+
+                        s.bitb = b; s.bitk = k;
+                        z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+                        s.writeAt = q;
+
+                        return ZlibConstants.Z_DATA_ERROR;
+                    }
+                }
+                while (true);
+            }
+            while (m >= 258 && n >= 10);
+
+            // not enough input or output--restore pointers and return
+            c = z.AvailableBytesIn - n; c = (k >> 3) < c ? k >> 3 : c; n += c; p -= c; k -= (c << 3);
+
+            s.bitb = b; s.bitk = k;
+            z.AvailableBytesIn = n; z.TotalBytesIn += p - z.NextIn; z.NextIn = p;
+            s.writeAt = q;
+
+            return ZlibConstants.Z_OK;
+        }
+    }
+
+
+    internal sealed class InflateManager
+    {
+        // preset dictionary flag in zlib header
+        private const int PRESET_DICT = 0x20;
+
+        private const int Z_DEFLATED = 8;
+
+        private enum InflateManagerMode
+        {
+            METHOD = 0,  // waiting for method byte
+            FLAG = 1,  // waiting for flag byte
+            DICT4 = 2,  // four dictionary check bytes to go
+            DICT3 = 3,  // three dictionary check bytes to go
+            DICT2 = 4,  // two dictionary check bytes to go
+            DICT1 = 5,  // one dictionary check byte to go
+            DICT0 = 6,  // waiting for inflateSetDictionary
+            BLOCKS = 7,  // decompressing blocks
+            CHECK4 = 8,  // four check bytes to go
+            CHECK3 = 9,  // three check bytes to go
+            CHECK2 = 10, // two check bytes to go
+            CHECK1 = 11, // one check byte to go
+            DONE = 12, // finished check, done
+            BAD = 13, // got an error--stay here
+        }
+
+        private InflateManagerMode mode; // current inflate mode
+        internal ZlibCodec _codec; // pointer back to this zlib stream
+
+        // mode dependent information
+        internal int method; // if FLAGS, method byte
+
+        // if CHECK, check values to compare
+        internal uint computedCheck; // computed check value
+        internal uint expectedCheck; // stream check value
+
+        // if BAD, inflateSync's marker bytes count
+        internal int marker;
+
+        // mode independent information
+        //internal int nowrap; // flag for no wrapper
+        private bool _handleRfc1950HeaderBytes = true;
+        internal bool HandleRfc1950HeaderBytes
+        {
+            get { return _handleRfc1950HeaderBytes; }
+            set { _handleRfc1950HeaderBytes = value; }
+        }
+        internal int wbits; // log2(window size)  (8..15, defaults to 15)
+
+        internal InflateBlocks blocks; // current inflate_blocks state
+
+        internal InflateManager() { }
+
+        internal InflateManager(bool expectRfc1950HeaderBytes)
+        {
+            _handleRfc1950HeaderBytes = expectRfc1950HeaderBytes;
+        }
+
+        internal int Reset()
+        {
+            _codec.TotalBytesIn = _codec.TotalBytesOut = 0;
+            _codec.Message = null;
+            mode = HandleRfc1950HeaderBytes ? InflateManagerMode.METHOD : InflateManagerMode.BLOCKS;
+            blocks.Reset();
+            return ZlibConstants.Z_OK;
+        }
+
+        internal int End()
+        {
+            if (blocks != null)
+                blocks.Free();
+            blocks = null;
+            return ZlibConstants.Z_OK;
+        }
+
+        internal int Initialize(ZlibCodec codec, int w)
+        {
+            _codec = codec;
+            _codec.Message = null;
+            blocks = null;
+
+            // handle undocumented nowrap option (no zlib header or check)
+            //nowrap = 0;
+            //if (w < 0)
+            //{
+            //    w = - w;
+            //    nowrap = 1;
+            //}
+
+            // set window size
+            if (w < 8 || w > 15)
+            {
+                End();
+                throw new ZlibException("Bad window size.");
+
+                //return ZlibConstants.Z_STREAM_ERROR;
+            }
+            wbits = w;
+
+            blocks = new InflateBlocks(codec,
+                HandleRfc1950HeaderBytes ? this : null,
+                1 << w);
+
+            // reset state
+            Reset();
+            return ZlibConstants.Z_OK;
+        }
+
+
+        internal int Inflate(FlushType flush)
+        {
+            int b;
+
+            if (_codec.InputBuffer == null)
+                throw new ZlibException("InputBuffer is null. ");
+
+            //             int f = (flush == FlushType.Finish)
+            //                 ? ZlibConstants.Z_BUF_ERROR
+            //                 : ZlibConstants.Z_OK;
+
+            // workitem 8870
+            int f = ZlibConstants.Z_OK;
+            int r = ZlibConstants.Z_BUF_ERROR;
+
+            while (true)
+            {
+                switch (mode)
+                {
+                    case InflateManagerMode.METHOD:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        if (((method = _codec.InputBuffer[_codec.NextIn++]) & 0xf) != Z_DEFLATED)
+                        {
+                            mode = InflateManagerMode.BAD;
+                            _codec.Message = String.Format("unknown compression method (0x{0:X2})", method);
+                            marker = 5; // can't try inflateSync
+                            break;
+                        }
+                        if ((method >> 4) + 8 > wbits)
+                        {
+                            mode = InflateManagerMode.BAD;
+                            _codec.Message = String.Format("invalid window size ({0})", (method >> 4) + 8);
+                            marker = 5; // can't try inflateSync
+                            break;
+                        }
+                        mode = InflateManagerMode.FLAG;
+                        break;
+
+
+                    case InflateManagerMode.FLAG:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        b = (_codec.InputBuffer[_codec.NextIn++]) & 0xff;
+
+                        if ((((method << 8) + b) % 31) != 0)
+                        {
+                            mode = InflateManagerMode.BAD;
+                            _codec.Message = "incorrect header check";
+                            marker = 5; // can't try inflateSync
+                            break;
+                        }
+
+                        mode = ((b & PRESET_DICT) == 0)
+                            ? InflateManagerMode.BLOCKS
+                            : InflateManagerMode.DICT4;
+                        break;
+
+                    case InflateManagerMode.DICT4:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        expectedCheck = (uint)((_codec.InputBuffer[_codec.NextIn++] << 24) & 0xff000000);
+                        mode = InflateManagerMode.DICT3;
+                        break;
+
+                    case InflateManagerMode.DICT3:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 16) & 0x00ff0000);
+                        mode = InflateManagerMode.DICT2;
+                        break;
+
+                    case InflateManagerMode.DICT2:
+
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 8) & 0x0000ff00);
+                        mode = InflateManagerMode.DICT1;
+                        break;
+
+
+                    case InflateManagerMode.DICT1:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--; _codec.TotalBytesIn++;
+                        expectedCheck += (uint)(_codec.InputBuffer[_codec.NextIn++] & 0x000000ff);
+                        _codec._Adler32 = expectedCheck;
+                        mode = InflateManagerMode.DICT0;
+                        return ZlibConstants.Z_NEED_DICT;
+
+
+                    case InflateManagerMode.DICT0:
+                        mode = InflateManagerMode.BAD;
+                        _codec.Message = "need dictionary";
+                        marker = 0; // can try inflateSync
+                        return ZlibConstants.Z_STREAM_ERROR;
+
+
+                    case InflateManagerMode.BLOCKS:
+                        r = blocks.Process(r);
+                        if (r == ZlibConstants.Z_DATA_ERROR)
+                        {
+                            mode = InflateManagerMode.BAD;
+                            marker = 0; // can try inflateSync
+                            break;
+                        }
+
+                        if (r == ZlibConstants.Z_OK) r = f;
+
+                        if (r != ZlibConstants.Z_STREAM_END)
+                            return r;
+
+                        r = f;
+                        computedCheck = blocks.Reset();
+                        if (!HandleRfc1950HeaderBytes)
+                        {
+                            mode = InflateManagerMode.DONE;
+                            return ZlibConstants.Z_STREAM_END;
+                        }
+                        mode = InflateManagerMode.CHECK4;
+                        break;
+
+                    case InflateManagerMode.CHECK4:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        expectedCheck = (uint)((_codec.InputBuffer[_codec.NextIn++] << 24) & 0xff000000);
+                        mode = InflateManagerMode.CHECK3;
+                        break;
+
+                    case InflateManagerMode.CHECK3:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--; _codec.TotalBytesIn++;
+                        expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 16) & 0x00ff0000);
+                        mode = InflateManagerMode.CHECK2;
+                        break;
+
+                    case InflateManagerMode.CHECK2:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--;
+                        _codec.TotalBytesIn++;
+                        expectedCheck += (uint)((_codec.InputBuffer[_codec.NextIn++] << 8) & 0x0000ff00);
+                        mode = InflateManagerMode.CHECK1;
+                        break;
+
+                    case InflateManagerMode.CHECK1:
+                        if (_codec.AvailableBytesIn == 0) return r;
+                        r = f;
+                        _codec.AvailableBytesIn--; _codec.TotalBytesIn++;
+                        expectedCheck += (uint)(_codec.InputBuffer[_codec.NextIn++] & 0x000000ff);
+                        if (computedCheck != expectedCheck)
+                        {
+                            mode = InflateManagerMode.BAD;
+                            _codec.Message = "incorrect data check";
+                            marker = 5; // can't try inflateSync
+                            break;
+                        }
+                        mode = InflateManagerMode.DONE;
+                        return ZlibConstants.Z_STREAM_END;
+
+                    case InflateManagerMode.DONE:
+                        return ZlibConstants.Z_STREAM_END;
+
+                    case InflateManagerMode.BAD:
+                        throw new ZlibException(String.Format("Bad state ({0})", _codec.Message));
+
+                    default:
+                        throw new ZlibException("Stream error.");
+
+                }
+            }
+        }
+
+
+
+        internal int SetDictionary(byte[] dictionary)
+        {
+            int index = 0;
+            int length = dictionary.Length;
+            if (mode != InflateManagerMode.DICT0)
+                throw new ZlibException("Stream error.");
+
+            if (Adler.Adler32(1, dictionary, 0, dictionary.Length) != _codec._Adler32)
+            {
+                return ZlibConstants.Z_DATA_ERROR;
+            }
+
+            _codec._Adler32 = Adler.Adler32(0, null, 0, 0);
+
+            if (length >= (1 << wbits))
+            {
+                length = (1 << wbits) - 1;
+                index = dictionary.Length - length;
+            }
+            blocks.SetDictionary(dictionary, index, length);
+            mode = InflateManagerMode.BLOCKS;
+            return ZlibConstants.Z_OK;
+        }
+
+
+        private static readonly byte[] mark = new byte[] { 0, 0, 0xff, 0xff };
+
+        internal int Sync()
+        {
+            int n; // number of bytes to look at
+            int p; // pointer to bytes
+            int m; // number of marker bytes found in a row
+            long r, w; // temporaries to save total_in and total_out
+
+            // set up
+            if (mode != InflateManagerMode.BAD)
+            {
+                mode = InflateManagerMode.BAD;
+                marker = 0;
+            }
+            if ((n = _codec.AvailableBytesIn) == 0)
+                return ZlibConstants.Z_BUF_ERROR;
+            p = _codec.NextIn;
+            m = marker;
+
+            // search
+            while (n != 0 && m < 4)
+            {
+                if (_codec.InputBuffer[p] == mark[m])
+                {
+                    m++;
+                }
+                else if (_codec.InputBuffer[p] != 0)
+                {
+                    m = 0;
+                }
+                else
+                {
+                    m = 4 - m;
+                }
+                p++; n--;
+            }
+
+            // restore
+            _codec.TotalBytesIn += p - _codec.NextIn;
+            _codec.NextIn = p;
+            _codec.AvailableBytesIn = n;
+            marker = m;
+
+            // return no joy or set up to restart on a new block
+            if (m != 4)
+            {
+                return ZlibConstants.Z_DATA_ERROR;
+            }
+            r = _codec.TotalBytesIn;
+            w = _codec.TotalBytesOut;
+            Reset();
+            _codec.TotalBytesIn = r;
+            _codec.TotalBytesOut = w;
+            mode = InflateManagerMode.BLOCKS;
+            return ZlibConstants.Z_OK;
+        }
+
+
+        // Returns true if inflate is currently at the end of a block generated
+        // by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
+        // implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH
+        // but removes the length bytes of the resulting empty stored block. When
+        // decompressing, PPP checks that at the end of input packet, inflate is
+        // waiting for these length bytes.
+        internal int SyncPoint(ZlibCodec z)
+        {
+            return blocks.SyncPoint();
+        }
+    }
+
+    /// <summary>
+    ///   A class for compressing and decompressing GZIP streams.
+    /// </summary>
+    /// <remarks>
+    ///
+    /// <para>
+    ///   The <c>GZipStream</c> is a <see
+    ///   href="http://en.wikipedia.org/wiki/Decorator_pattern">Decorator</see> on a
+    ///   <see cref="Stream"/>. It adds GZIP compression or decompression to any
+    ///   stream.
+    /// </para>
+    ///
+    /// <para>
+    ///   Like the <c>System.IO.Compression.GZipStream</c> in the .NET Base Class Library, the
+    ///   <c>Ionic.Zlib.GZipStream</c> can compress while writing, or decompress while
+    ///   reading, but not vice versa.  The compression method used is GZIP, which is
+    ///   documented in <see href="http://www.ietf.org/rfc/rfc1952.txt">IETF RFC
+    ///   1952</see>, "GZIP file format specification version 4.3".</para>
+    ///
+    /// <para>
+    ///   A <c>GZipStream</c> can be used to decompress data (through <c>Read()</c>) or
+    ///   to compress data (through <c>Write()</c>), but not both.
+    /// </para>
+    ///
+    /// <para>
+    ///   If you wish to use the <c>GZipStream</c> to compress data, you must wrap it
+    ///   around a write-able stream. As you call <c>Write()</c> on the <c>GZipStream</c>, the
+    ///   data will be compressed into the GZIP format.  If you want to decompress data,
+    ///   you must wrap the <c>GZipStream</c> around a readable stream that contains an
+    ///   IETF RFC 1952-compliant stream.  The data will be decompressed as you call
+    ///   <c>Read()</c> on the <c>GZipStream</c>.
+    /// </para>
+    ///
+    /// <para>
+    ///   Though the GZIP format allows data from multiple files to be concatenated
+    ///   together, this stream handles only a single segment of GZIP format, typically
+    ///   representing a single file.
+    /// </para>
+    ///
+    ///
+    /// </remarks>
+    internal class GZipStream : Stream
+    {
+        // GZip format
+        // source: http://tools.ietf.org/html/rfc1952
+        //
+        //  header id:           2 bytes    1F 8B
+        //  compress method      1 byte     8= DEFLATE (none other supported)
+        //  flag                 1 byte     bitfield (See below)
+        //  mtime                4 bytes    time_t (seconds since jan 1, 1970 UTC of the file.
+        //  xflg                 1 byte     2 = max compress used , 4 = max speed (can be ignored)
+        //  OS                   1 byte     OS for originating archive. set to 0xFF in compression.
+        //  extra field length   2 bytes    optional - only if FEXTRA is set.
+        //  extra field          varies
+        //  filename             varies     optional - if FNAME is set.  zero terminated. ISO-8859-1.
+        //  file comment         varies     optional - if FCOMMENT is set. zero terminated. ISO-8859-1.
+        //  crc16                1 byte     optional - present only if FHCRC bit is set
+        //  compressed data      varies
+        //  CRC32                4 bytes
+        //  isize                4 bytes    data size modulo 2^32
+        //
+        //     FLG (FLaGs)
+        //                bit 0   FTEXT - indicates file is ASCII text (can be safely ignored)
+        //                bit 1   FHCRC - there is a CRC16 for the header immediately following the header
+        //                bit 2   FEXTRA - extra fields are present
+        //                bit 3   FNAME - the zero-terminated filename is present. encoding; ISO-8859-1.
+        //                bit 4   FCOMMENT  - a zero-terminated file comment is present. encoding: ISO-8859-1
+        //                bit 5   reserved
+        //                bit 6   reserved
+        //                bit 7   reserved
+        //
+        // On consumption:
+        // Extra field is a bunch of nonsense and can be safely ignored.
+        // Header CRC and OS, likewise.
+        //
+        // on generation:
+        // all optional fields get 0, except for the OS, which gets 255.
+        //
+
+
+
+        /// <summary>
+        ///   The comment on the GZIP stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        /// <para>
+        ///   The GZIP format allows for each file to optionally have an associated
+        ///   comment stored with the file.  The comment is encoded with the ISO-8859-1
+        ///   code page.  To include a comment in a GZIP stream you create, set this
+        ///   property before calling <c>Write()</c> for the first time on the
+        ///   <c>GZipStream</c>.
+        /// </para>
+        ///
+        /// <para>
+        ///   When using <c>GZipStream</c> to decompress, you can retrieve this property
+        ///   after the first call to <c>Read()</c>.  If no comment has been set in the
+        ///   GZIP bytestream, the Comment property will return <c>null</c>
+        ///   (<c>Nothing</c> in VB).
+        /// </para>
+        /// </remarks>
+        internal String Comment
+        {
+            get
+            {
+                return _Comment;
+            }
+            set
+            {
+                if (_disposed) throw new ObjectDisposedException("GZipStream");
+                _Comment = value;
+            }
+        }
+
+        /// <summary>
+        ///   The FileName for the GZIP stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   The GZIP format optionally allows each file to have an associated
+        ///   filename.  When compressing data (through <c>Write()</c>), set this
+        ///   FileName before calling <c>Write()</c> the first time on the <c>GZipStream</c>.
+        ///   The actual filename is encoded into the GZIP bytestream with the
+        ///   ISO-8859-1 code page, according to RFC 1952. It is the application's
+        ///   responsibility to insure that the FileName can be encoded and decoded
+        ///   correctly with this code page.
+        /// </para>
+        ///
+        /// <para>
+        ///   When decompressing (through <c>Read()</c>), you can retrieve this value
+        ///   any time after the first <c>Read()</c>.  In the case where there was no filename
+        ///   encoded into the GZIP bytestream, the property will return <c>null</c> (<c>Nothing</c>
+        ///   in VB).
+        /// </para>
+        /// </remarks>
+        internal String FileName
+        {
+            get { return _FileName; }
+            set
+            {
+                if (_disposed) throw new ObjectDisposedException("GZipStream");
+                _FileName = value;
+                if (_FileName == null) return;
+                if (_FileName.IndexOf("/") != -1)
+                {
+                    _FileName = _FileName.Replace("/", "\\");
+                }
+                if (_FileName.EndsWith("\\"))
+                    throw new Exception("Illegal filename");
+                if (_FileName.IndexOf("\\") != -1)
+                {
+                    // trim any leading path
+                    _FileName = Path.GetFileName(_FileName);
+                }
+            }
+        }
+
+        /// <summary>
+        ///   The last modified time for the GZIP stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   GZIP allows the storage of a last modified time with each GZIP entry.
+        ///   When compressing data, you can set this before the first call to
+        ///   <c>Write()</c>.  When decompressing, you can retrieve this value any time
+        ///   after the first call to <c>Read()</c>.
+        /// </remarks>
+        internal DateTime? LastModified;
+
+        /// <summary>
+        /// The CRC on the GZIP stream.
+        /// </summary>
+        /// <remarks>
+        /// This is used for internal error checking. You probably don't need to look at this property.
+        /// </remarks>
+        internal int Crc32 { get { return _Crc32; } }
+
+        private int _headerByteCount;
+        internal ZlibBaseStream _baseStream;
+        bool _disposed;
+        bool _firstReadDone;
+        string _FileName;
+        string _Comment;
+        int _Crc32;
+
+
+        /// <summary>
+        ///   Create a <c>GZipStream</c> using the specified <c>CompressionMode</c>.
+        /// </summary>
+        /// <remarks>
+        ///
+        /// <para>
+        ///   When mode is <c>CompressionMode.Compress</c>, the <c>GZipStream</c> will use the
+        ///   default compression level.
+        /// </para>
+        ///
+        /// <para>
+        ///   As noted in the class documentation, the <c>CompressionMode</c> (Compress
+        ///   or Decompress) also establishes the "direction" of the stream.  A
+        ///   <c>GZipStream</c> with <c>CompressionMode.Compress</c> works only through
+        ///   <c>Write()</c>.  A <c>GZipStream</c> with
+        ///   <c>CompressionMode.Decompress</c> works only through <c>Read()</c>.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        ///   This example shows how to use a GZipStream to compress data.
+        /// <code>
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        /// {
+        ///     using (var raw = System.IO.File.Create(outputFile))
+        ///     {
+        ///         using (Stream compressor = new GZipStream(raw, CompressionMode.Compress))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n;
+        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
+        ///             {
+        ///                 compressor.Write(buffer, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        /// <code lang="VB">
+        /// Dim outputFile As String = (fileToCompress &amp; ".compressed")
+        /// Using input As Stream = File.OpenRead(fileToCompress)
+        ///     Using raw As FileStream = File.Create(outputFile)
+        ///     Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress)
+        ///         Dim buffer As Byte() = New Byte(4096) {}
+        ///         Dim n As Integer = -1
+        ///         Do While (n &lt;&gt; 0)
+        ///             If (n &gt; 0) Then
+        ///                 compressor.Write(buffer, 0, n)
+        ///             End If
+        ///             n = input.Read(buffer, 0, buffer.Length)
+        ///         Loop
+        ///     End Using
+        ///     End Using
+        /// End Using
+        /// </code>
+        /// </example>
+        ///
+        /// <example>
+        /// This example shows how to use a GZipStream to uncompress a file.
+        /// <code>
+        /// private void GunZipFile(string filename)
+        /// {
+        ///     if (!filename.EndsWith(".gz))
+        ///         throw new ArgumentException("filename");
+        ///     var DecompressedFile = filename.Substring(0,filename.Length-3);
+        ///     byte[] working = new byte[WORKING_BUFFER_SIZE];
+        ///     int n= 1;
+        ///     using (System.IO.Stream input = System.IO.File.OpenRead(filename))
+        ///     {
+        ///         using (Stream decompressor= new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, true))
+        ///         {
+        ///             using (var output = System.IO.File.Create(DecompressedFile))
+        ///             {
+        ///                 while (n !=0)
+        ///                 {
+        ///                     n= decompressor.Read(working, 0, working.Length);
+        ///                     if (n > 0)
+        ///                     {
+        ///                         output.Write(working, 0, n);
+        ///                     }
+        ///                 }
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        ///
+        /// <code lang="VB">
+        /// Private Sub GunZipFile(ByVal filename as String)
+        ///     If Not (filename.EndsWith(".gz)) Then
+        ///         Throw New ArgumentException("filename")
+        ///     End If
+        ///     Dim DecompressedFile as String = filename.Substring(0,filename.Length-3)
+        ///     Dim working(WORKING_BUFFER_SIZE) as Byte
+        ///     Dim n As Integer = 1
+        ///     Using input As Stream = File.OpenRead(filename)
+        ///         Using decompressor As Stream = new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, True)
+        ///             Using output As Stream = File.Create(UncompressedFile)
+        ///                 Do
+        ///                     n= decompressor.Read(working, 0, working.Length)
+        ///                     If n > 0 Then
+        ///                         output.Write(working, 0, n)
+        ///                     End IF
+        ///                 Loop While (n  > 0)
+        ///             End Using
+        ///         End Using
+        ///     End Using
+        /// End Sub
+        /// </code>
+        /// </example>
+        ///
+        /// <param name="stream">The stream which will be read or written.</param>
+        /// <param name="mode">Indicates whether the GZipStream will compress or decompress.</param>
+        internal GZipStream(Stream stream, CompressionMode mode)
+            : this(stream, mode, CompressionLevel.Default, false)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>GZipStream</c> using the specified <c>CompressionMode</c> and
+        ///   the specified <c>CompressionLevel</c>.
+        /// </summary>
+        /// <remarks>
+        ///
+        /// <para>
+        ///   The <c>CompressionMode</c> (Compress or Decompress) also establishes the
+        ///   "direction" of the stream.  A <c>GZipStream</c> with
+        ///   <c>CompressionMode.Compress</c> works only through <c>Write()</c>.  A
+        ///   <c>GZipStream</c> with <c>CompressionMode.Decompress</c> works only
+        ///   through <c>Read()</c>.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        ///
+        /// This example shows how to use a <c>GZipStream</c> to compress a file into a .gz file.
+        ///
+        /// <code>
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        /// {
+        ///     using (var raw = System.IO.File.Create(fileToCompress + ".gz"))
+        ///     {
+        ///         using (Stream compressor = new GZipStream(raw,
+        ///                                                   CompressionMode.Compress,
+        ///                                                   CompressionLevel.BestCompression))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n;
+        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
+        ///             {
+        ///                 compressor.Write(buffer, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        ///
+        /// <code lang="VB">
+        /// Using input As Stream = File.OpenRead(fileToCompress)
+        ///     Using raw As FileStream = File.Create(fileToCompress &amp; ".gz")
+        ///         Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
+        ///             Dim buffer As Byte() = New Byte(4096) {}
+        ///             Dim n As Integer = -1
+        ///             Do While (n &lt;&gt; 0)
+        ///                 If (n &gt; 0) Then
+        ///                     compressor.Write(buffer, 0, n)
+        ///                 End If
+        ///                 n = input.Read(buffer, 0, buffer.Length)
+        ///             Loop
+        ///         End Using
+        ///     End Using
+        /// End Using
+        /// </code>
+        /// </example>
+        /// <param name="stream">The stream to be read or written while deflating or inflating.</param>
+        /// <param name="mode">Indicates whether the <c>GZipStream</c> will compress or decompress.</param>
+        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
+        internal GZipStream(Stream stream, CompressionMode mode, CompressionLevel level)
+            : this(stream, mode, level, false)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>GZipStream</c> using the specified <c>CompressionMode</c>, and
+        ///   explicitly specify whether the stream should be left open after Deflation
+        ///   or Inflation.
+        /// </summary>
+        ///
+        /// <remarks>
+        /// <para>
+        ///   This constructor allows the application to request that the captive stream
+        ///   remain open after the deflation or inflation occurs.  By default, after
+        ///   <c>Close()</c> is called on the stream, the captive stream is also
+        ///   closed. In some cases this is not desired, for example if the stream is a
+        ///   memory stream that will be re-read after compressed data has been written
+        ///   to it.  Specify true for the <paramref name="leaveOpen"/> parameter to leave
+        ///   the stream open.
+        /// </para>
+        ///
+        /// <para>
+        ///   The <see cref="CompressionMode"/> (Compress or Decompress) also
+        ///   establishes the "direction" of the stream.  A <c>GZipStream</c> with
+        ///   <c>CompressionMode.Compress</c> works only through <c>Write()</c>.  A <c>GZipStream</c>
+        ///   with <c>CompressionMode.Decompress</c> works only through <c>Read()</c>.
+        /// </para>
+        ///
+        /// <para>
+        ///   The <c>GZipStream</c> will use the default compression level. If you want
+        ///   to specify the compression level, see <see cref="GZipStream(Stream,
+        ///   CompressionMode, CompressionLevel, bool)"/>.
+        /// </para>
+        ///
+        /// <para>
+        ///   See the other overloads of this constructor for example code.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <param name="stream">
+        ///   The stream which will be read or written. This is called the "captive"
+        ///   stream in other places in this documentation.
+        /// </param>
+        ///
+        /// <param name="mode">Indicates whether the GZipStream will compress or decompress.
+        /// </param>
+        ///
+        /// <param name="leaveOpen">
+        ///   true if the application would like the base stream to remain open after
+        ///   inflation/deflation.
+        /// </param>
+        internal GZipStream(Stream stream, CompressionMode mode, bool leaveOpen)
+            : this(stream, mode, CompressionLevel.Default, leaveOpen)
+        {
+        }
+
+        /// <summary>
+        ///   Create a <c>GZipStream</c> using the specified <c>CompressionMode</c> and the
+        ///   specified <c>CompressionLevel</c>, and explicitly specify whether the
+        ///   stream should be left open after Deflation or Inflation.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///
+        /// <para>
+        ///   This constructor allows the application to request that the captive stream
+        ///   remain open after the deflation or inflation occurs.  By default, after
+        ///   <c>Close()</c> is called on the stream, the captive stream is also
+        ///   closed. In some cases this is not desired, for example if the stream is a
+        ///   memory stream that will be re-read after compressed data has been written
+        ///   to it.  Specify true for the <paramref name="leaveOpen"/> parameter to
+        ///   leave the stream open.
+        /// </para>
+        ///
+        /// <para>
+        ///   As noted in the class documentation, the <c>CompressionMode</c> (Compress
+        ///   or Decompress) also establishes the "direction" of the stream.  A
+        ///   <c>GZipStream</c> with <c>CompressionMode.Compress</c> works only through
+        ///   <c>Write()</c>.  A <c>GZipStream</c> with <c>CompressionMode.Decompress</c> works only
+        ///   through <c>Read()</c>.
+        /// </para>
+        ///
+        /// </remarks>
+        ///
+        /// <example>
+        ///   This example shows how to use a <c>GZipStream</c> to compress data.
+        /// <code>
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
+        /// {
+        ///     using (var raw = System.IO.File.Create(outputFile))
+        ///     {
+        ///         using (Stream compressor = new GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression, true))
+        ///         {
+        ///             byte[] buffer = new byte[WORKING_BUFFER_SIZE];
+        ///             int n;
+        ///             while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
+        ///             {
+        ///                 compressor.Write(buffer, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        /// <code lang="VB">
+        /// Dim outputFile As String = (fileToCompress &amp; ".compressed")
+        /// Using input As Stream = File.OpenRead(fileToCompress)
+        ///     Using raw As FileStream = File.Create(outputFile)
+        ///     Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression, True)
+        ///         Dim buffer As Byte() = New Byte(4096) {}
+        ///         Dim n As Integer = -1
+        ///         Do While (n &lt;&gt; 0)
+        ///             If (n &gt; 0) Then
+        ///                 compressor.Write(buffer, 0, n)
+        ///             End If
+        ///             n = input.Read(buffer, 0, buffer.Length)
+        ///         Loop
+        ///     End Using
+        ///     End Using
+        /// End Using
+        /// </code>
+        /// </example>
+        /// <param name="stream">The stream which will be read or written.</param>
+        /// <param name="mode">Indicates whether the GZipStream will compress or decompress.</param>
+        /// <param name="leaveOpen">true if the application would like the stream to remain open after inflation/deflation.</param>
+        /// <param name="level">A tuning knob to trade speed for effectiveness.</param>
+        internal GZipStream(Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
+        {
+            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.GZIP, leaveOpen);
+        }
+
+        #region Zlib properties
+
+        /// <summary>
+        /// This property sets the flush behavior on the stream.
+        /// </summary>
+        virtual internal FlushType FlushMode
+        {
+            get { return (this._baseStream._flushMode); }
+            set
+            {
+                if (_disposed) throw new ObjectDisposedException("GZipStream");
+                this._baseStream._flushMode = value;
+            }
+        }
+
+        /// <summary>
+        ///   The size of the working buffer for the compression codec.
+        /// </summary>
+        ///
+        /// <remarks>
+        /// <para>
+        ///   The working buffer is used for all stream operations.  The default size is
+        ///   1024 bytes.  The minimum size is 128 bytes. You may get better performance
+        ///   with a larger buffer.  Then again, you might not.  You would have to test
+        ///   it.
+        /// </para>
+        ///
+        /// <para>
+        ///   Set this before the first call to <c>Read()</c> or <c>Write()</c> on the
+        ///   stream. If you try to set it afterwards, it will throw.
+        /// </para>
+        /// </remarks>
+        internal int BufferSize
+        {
+            get
+            {
+                return this._baseStream._bufferSize;
+            }
+            set
+            {
+                if (_disposed) throw new ObjectDisposedException("GZipStream");
+                if (this._baseStream._workingBuffer != null)
+                    throw new ZlibException("The working buffer is already set.");
+                if (value < ZlibConstants.WorkingBufferSizeMin)
+                    throw new ZlibException(String.Format("Don't be silly. {0} bytes?? Use a bigger buffer, at least {1}.", value, ZlibConstants.WorkingBufferSizeMin));
+                this._baseStream._bufferSize = value;
+            }
+        }
+
+
+        /// <summary> Returns the total number of bytes input so far.</summary>
+        virtual internal long TotalIn
+        {
+            get
+            {
+                return this._baseStream._z.TotalBytesIn;
+            }
+        }
+
+        /// <summary> Returns the total number of bytes output so far.</summary>
+        virtual internal long TotalOut
+        {
+            get
+            {
+                return this._baseStream._z.TotalBytesOut;
+            }
+        }
+
+        #endregion
+
+        #region Stream methods
+
+        /// <summary>
+        ///   Dispose the stream.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     This may or may not result in a <c>Close()</c> call on the captive
+        ///     stream.  See the constructors that have a <c>leaveOpen</c> parameter
+        ///     for more information.
+        ///   </para>
+        ///   <para>
+        ///     This method may be invoked in two distinct scenarios.  If disposing
+        ///     == true, the method has been called directly or indirectly by a
+        ///     user's code, for example via the internal Dispose() method. In this
+        ///     case, both managed and unmanaged resources can be referenced and
+        ///     disposed.  If disposing == false, the method has been called by the
+        ///     runtime from inside the object finalizer and this method should not
+        ///     reference other objects; in that case only unmanaged resources must
+        ///     be referenced or disposed.
+        ///   </para>
+        /// </remarks>
+        /// <param name="disposing">
+        ///   indicates whether the Dispose method was invoked by user code.
+        /// </param>
+        protected override void Dispose(bool disposing)
+        {
+            try
+            {
+                if (!_disposed)
+                {
+                    if (disposing && (this._baseStream != null))
+                    {
+                        this._baseStream.Dispose();
+                        this._Crc32 = _baseStream.Crc32;
+                    }
+                    _disposed = true;
+                }
+            }
+            finally
+            {
+                base.Dispose(disposing);
+            }
+        }
+
+
+        /// <summary>
+        /// Indicates whether the stream can be read.
+        /// </summary>
+        /// <remarks>
+        /// The return value depends on whether the captive stream supports reading.
+        /// </remarks>
+        public override bool CanRead
+        {
+            get
+            {
+                if (_disposed) throw new ObjectDisposedException("GZipStream");
+                return _baseStream._stream.CanRead;
+            }
+        }
+
+        /// <summary>
+        /// Indicates whether the stream supports Seek operations.
+        /// </summary>
+        /// <remarks>
+        /// Always returns false.
+        /// </remarks>
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+
+        /// <summary>
+        /// Indicates whether the stream can be written.
+        /// </summary>
+        /// <remarks>
+        /// The return value depends on whether the captive stream supports writing.
+        /// </remarks>
+        public override bool CanWrite
+        {
+            get
+            {
+                if (_disposed) throw new ObjectDisposedException("GZipStream");
+                return _baseStream._stream.CanWrite;
+            }
+        }
+
+        /// <summary>
+        /// Flush the stream.
+        /// </summary>
+        public override void Flush()
+        {
+            if (_disposed) throw new ObjectDisposedException("GZipStream");
+            _baseStream.Flush();
+        }
+
+        /// <summary>
+        /// Reading this property always throws a <see cref="NotImplementedException"/>.
+        /// </summary>
+        public override long Length
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        /// <summary>
+        ///   The position of the stream pointer.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Setting this property always throws a <see
+        ///   cref="NotImplementedException"/>. Reading will return the total bytes
+        ///   written out, if used in writing, or the total bytes read in, if used in
+        ///   reading.  The count may refer to compressed bytes or uncompressed bytes,
+        ///   depending on how you've used the stream.
+        /// </remarks>
+        public override long Position
+        {
+            get
+            {
+                if (this._baseStream._streamMode == ZlibBaseStream.StreamMode.Writer)
+                    return this._baseStream._z.TotalBytesOut + _headerByteCount;
+                if (this._baseStream._streamMode == ZlibBaseStream.StreamMode.Reader)
+                    return this._baseStream._z.TotalBytesIn + this._baseStream._gzipHeaderByteCount;
+                return 0;
+            }
+
+            set { throw new NotImplementedException(); }
+        }
+
+        /// <summary>
+        ///   Read and decompress data from the source stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   With a <c>GZipStream</c>, decompression is done through reading.
+        /// </remarks>
+        ///
+        /// <example>
+        /// <code>
+        /// byte[] working = new byte[WORKING_BUFFER_SIZE];
+        /// using (System.IO.Stream input = System.IO.File.OpenRead(_CompressedFile))
+        /// {
+        ///     using (Stream decompressor= new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, true))
+        ///     {
+        ///         using (var output = System.IO.File.Create(_DecompressedFile))
+        ///         {
+        ///             int n;
+        ///             while ((n= decompressor.Read(working, 0, working.Length)) !=0)
+        ///             {
+        ///                 output.Write(working, 0, n);
+        ///             }
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
+        /// <param name="buffer">The buffer into which the decompressed data should be placed.</param>
+        /// <param name="offset">the offset within that data array to put the first byte read.</param>
+        /// <param name="count">the number of bytes to read.</param>
+        /// <returns>the number of bytes actually read</returns>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (_disposed) throw new ObjectDisposedException("GZipStream");
+            int n = _baseStream.Read(buffer, offset, count);
+
+            // Console.WriteLine("GZipStream::Read(buffer, off({0}), c({1}) = {2}", offset, count, n);
+            // Console.WriteLine( Util.FormatByteArray(buffer, offset, n) );
+
+            if (!_firstReadDone)
+            {
+                _firstReadDone = true;
+                FileName = _baseStream._GzipFileName;
+                Comment = _baseStream._GzipComment;
+            }
+            return n;
+        }
+
+
+
+        /// <summary>
+        ///   Calling this method always throws a <see cref="NotImplementedException"/>.
+        /// </summary>
+        /// <param name="offset">irrelevant; it will always throw!</param>
+        /// <param name="origin">irrelevant; it will always throw!</param>
+        /// <returns>irrelevant!</returns>
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        ///   Calling this method always throws a <see cref="NotImplementedException"/>.
+        /// </summary>
+        /// <param name="value">irrelevant; this method will always throw!</param>
+        public override void SetLength(long value)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        ///   Write data to the stream.
+        /// </summary>
+        ///
+        /// <remarks>
+        /// <para>
+        ///   If you wish to use the <c>GZipStream</c> to compress data while writing,
+        ///   you can create a <c>GZipStream</c> with <c>CompressionMode.Compress</c>, and a
+        ///   writable output stream.  Then call <c>Write()</c> on that <c>GZipStream</c>,
+        ///   providing uncompressed data as input.  The data sent to the output stream
+        ///   will be the compressed form of the data written.
+        /// </para>
+        ///
+        /// <para>
+        ///   A <c>GZipStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but not
+        ///   both. Writing implies compression.  Reading implies decompression.
+        /// </para>
+        ///
+        /// </remarks>
+        /// <param name="buffer">The buffer holding data to write to the stream.</param>
+        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
+        /// <param name="count">the number of bytes to write.</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (_disposed) throw new ObjectDisposedException("GZipStream");
+            if (_baseStream._streamMode == ZlibBaseStream.StreamMode.Undefined)
+            {
+                //Console.WriteLine("GZipStream: First write");
+                if (_baseStream._wantCompress)
+                {
+                    // first write in compression, therefore, emit the GZIP header
+                    _headerByteCount = EmitHeader();
+                }
+                else
+                {
+                    throw new InvalidOperationException();
+                }
+            }
+
+            _baseStream.Write(buffer, offset, count);
+        }
+        #endregion
+
+
+        internal static readonly System.DateTime _unixEpoch = new System.DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        internal static readonly System.Text.Encoding iso8859dash1 = new Iso88591Encoding();
+
+        private int EmitHeader()
+        {
+            byte[] commentBytes = (Comment == null) ? null : iso8859dash1.GetBytes(Comment);
+            byte[] filenameBytes = (FileName == null) ? null : iso8859dash1.GetBytes(FileName);
+
+            int cbLength = (Comment == null) ? 0 : commentBytes.Length + 1;
+            int fnLength = (FileName == null) ? 0 : filenameBytes.Length + 1;
+
+            int bufferLength = 10 + cbLength + fnLength;
+            byte[] header = new byte[bufferLength];
+            int i = 0;
+            // ID
+            header[i++] = 0x1F;
+            header[i++] = 0x8B;
+
+            // compression method
+            header[i++] = 8;
+            byte flag = 0;
+            if (Comment != null)
+                flag ^= 0x10;
+            if (FileName != null)
+                flag ^= 0x8;
+
+            // flag
+            header[i++] = flag;
+
+            // mtime
+            if (!LastModified.HasValue) LastModified = DateTime.Now;
+            System.TimeSpan delta = LastModified.Value - _unixEpoch;
+            Int32 timet = (Int32)delta.TotalSeconds;
+            Array.Copy(BitConverter.GetBytes(timet), 0, header, i, 4);
+            i += 4;
+
+            // xflg
+            header[i++] = 0;    // this field is totally useless
+            // OS
+            header[i++] = 0xFF; // 0xFF == unspecified
+
+            // extra field length - only if FEXTRA is set, which it is not.
+            //header[i++]= 0;
+            //header[i++]= 0;
+
+            // filename
+            if (fnLength != 0)
+            {
+                Array.Copy(filenameBytes, 0, header, i, fnLength - 1);
+                i += fnLength - 1;
+                header[i++] = 0; // terminate
+            }
+
+            // comment
+            if (cbLength != 0)
+            {
+                Array.Copy(commentBytes, 0, header, i, cbLength - 1);
+                i += cbLength - 1;
+                header[i++] = 0; // terminate
+            }
+
+            _baseStream._stream.Write(header, 0, header.Length);
+
+            return header.Length; // bytes written
+        }
+
+
+
+        /// <summary>
+        ///   Compress a string into a byte array using GZip.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Uncompress it with <see cref="GZipStream.UncompressString(byte[])"/>.
+        /// </remarks>
+        ///
+        /// <seealso cref="GZipStream.UncompressString(byte[])"/>
+        /// <seealso cref="GZipStream.CompressBuffer(byte[])"/>
+        ///
+        /// <param name="s">
+        ///   A string to compress. The string will first be encoded
+        ///   using UTF8, then compressed.
+        /// </param>
+        ///
+        /// <returns>The string in compressed form</returns>
+        internal static byte[] CompressString(String s)
+        {
+            using (var ms = new MemoryStream())
+            {
+                System.IO.Stream compressor =
+                    new GZipStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression);
+                ZlibBaseStream.CompressString(s, compressor);
+                return ms.ToArray();
+            }
+        }
+
+
+        /// <summary>
+        ///   Compress a byte array into a new byte array using GZip.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   Uncompress it with <see cref="GZipStream.UncompressBuffer(byte[])"/>.
+        /// </remarks>
+        ///
+        /// <seealso cref="GZipStream.CompressString(string)"/>
+        /// <seealso cref="GZipStream.UncompressBuffer(byte[])"/>
+        ///
+        /// <param name="b">
+        ///   A buffer to compress.
+        /// </param>
+        ///
+        /// <returns>The data in compressed form</returns>
+        internal static byte[] CompressBuffer(byte[] b)
+        {
+            using (var ms = new MemoryStream())
+            {
+                System.IO.Stream compressor =
+                    new GZipStream(ms, CompressionMode.Compress, CompressionLevel.BestCompression);
+
+                ZlibBaseStream.CompressBuffer(b, compressor);
+                return ms.ToArray();
+            }
+        }
+
+
+        /// <summary>
+        ///   Uncompress a GZip'ed byte array into a single string.
+        /// </summary>
+        ///
+        /// <seealso cref="GZipStream.CompressString(String)"/>
+        /// <seealso cref="GZipStream.UncompressBuffer(byte[])"/>
+        ///
+        /// <param name="compressed">
+        ///   A buffer containing GZIP-compressed data.
+        /// </param>
+        ///
+        /// <returns>The uncompressed string</returns>
+        internal static String UncompressString(byte[] compressed)
+        {
+            using (var input = new MemoryStream(compressed))
+            {
+                Stream decompressor = new GZipStream(input, CompressionMode.Decompress);
+                return ZlibBaseStream.UncompressString(compressed, decompressor);
+            }
+        }
+
+
+        /// <summary>
+        ///   Uncompress a GZip'ed byte array into a byte array.
+        /// </summary>
+        ///
+        /// <seealso cref="GZipStream.CompressBuffer(byte[])"/>
+        /// <seealso cref="GZipStream.UncompressString(byte[])"/>
+        ///
+        /// <param name="compressed">
+        ///   A buffer containing data that has been compressed with GZip.
+        /// </param>
+        ///
+        /// <returns>The data in uncompressed form</returns>
+        internal static byte[] UncompressBuffer(byte[] compressed)
+        {
+            using (var input = new System.IO.MemoryStream(compressed))
+            {
+                System.IO.Stream decompressor =
+                    new GZipStream(input, CompressionMode.Decompress);
+
+                return ZlibBaseStream.UncompressBuffer(compressed, decompressor);
+            }
+        }
+
+
+    }
+
+    internal enum BlockState
+    {
+        NeedMore = 0,       // block not completed, need more input or more output
+        BlockDone,          // block flush performed
+        FinishStarted,              // finish started, need only more output at next deflate
+        FinishDone          // finish done, accept no more input or output
+    }
+
+    internal enum DeflateFlavor
+    {
+        Store,
+        Fast,
+        Slow
+    }
+
+    internal sealed class DeflateManager
+    {
+        private static readonly int MEM_LEVEL_MAX = 9;
+        private static readonly int MEM_LEVEL_DEFAULT = 8;
+
+        internal delegate BlockState CompressFunc(FlushType flush);
+
+        internal class Config
+        {
+            // Use a faster search when the previous match is longer than this
+            internal int GoodLength; // reduce lazy search above this match length
+
+            // Attempt to find a better match only when the current match is
+            // strictly smaller than this value. This mechanism is used only for
+            // compression levels >= 4.  For levels 1,2,3: MaxLazy is actually
+            // MaxInsertLength. (See DeflateFast)
+
+            internal int MaxLazy;    // do not perform lazy search above this match length
+
+            internal int NiceLength; // quit search above this match length
+
+            // To speed up deflation, hash chains are never searched beyond this
+            // length.  A higher limit improves compression ratio but degrades the speed.
+
+            internal int MaxChainLength;
+
+            internal DeflateFlavor Flavor;
+
+            private Config(int goodLength, int maxLazy, int niceLength, int maxChainLength, DeflateFlavor flavor)
+            {
+                this.GoodLength = goodLength;
+                this.MaxLazy = maxLazy;
+                this.NiceLength = niceLength;
+                this.MaxChainLength = maxChainLength;
+                this.Flavor = flavor;
+            }
+
+            internal static Config Lookup(CompressionLevel level)
+            {
+                return Table[(int)level];
+            }
+
+
+            static Config()
+            {
+                Table = new Config[] {
+                    new Config(0, 0, 0, 0, DeflateFlavor.Store),
+                    new Config(4, 4, 8, 4, DeflateFlavor.Fast),
+                    new Config(4, 5, 16, 8, DeflateFlavor.Fast),
+                    new Config(4, 6, 32, 32, DeflateFlavor.Fast),
+
+                    new Config(4, 4, 16, 16, DeflateFlavor.Slow),
+                    new Config(8, 16, 32, 32, DeflateFlavor.Slow),
+                    new Config(8, 16, 128, 128, DeflateFlavor.Slow),
+                    new Config(8, 32, 128, 256, DeflateFlavor.Slow),
+                    new Config(32, 128, 258, 1024, DeflateFlavor.Slow),
+                    new Config(32, 258, 258, 4096, DeflateFlavor.Slow),
+                };
+            }
+
+            private static readonly Config[] Table;
+        }
+
+
+        private CompressFunc DeflateFunction;
+
+        private static readonly System.String[] _ErrorMessage = new System.String[]
+        {
+            "need dictionary",
+            "stream end",
+            "",
+            "file error",
+            "stream error",
+            "data error",
+            "insufficient memory",
+            "buffer error",
+            "incompatible version",
+            ""
+        };
+
+        // preset dictionary flag in zlib header
+        private static readonly int PRESET_DICT = 0x20;
+
+        private static readonly int INIT_STATE = 42;
+        private static readonly int BUSY_STATE = 113;
+        private static readonly int FINISH_STATE = 666;
+
+        // The deflate compression method
+        private static readonly int Z_DEFLATED = 8;
+
+        private static readonly int STORED_BLOCK = 0;
+        private static readonly int STATIC_TREES = 1;
+        private static readonly int DYN_TREES = 2;
+
+        // The three kinds of block type
+        private static readonly int Z_BINARY = 0;
+        private static readonly int Z_ASCII = 1;
+        private static readonly int Z_UNKNOWN = 2;
+
+        private static readonly int Buf_size = 8 * 2;
+
+        private static readonly int MIN_MATCH = 3;
+        private static readonly int MAX_MATCH = 258;
+
+        private static readonly int MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1);
+
+        private static readonly int HEAP_SIZE = (2 * InternalConstants.L_CODES + 1);
+
+        private static readonly int END_BLOCK = 256;
+
+        internal ZlibCodec _codec; // the zlib encoder/decoder
+        internal int status;       // as the name implies
+        internal byte[] pending;   // output still pending - waiting to be compressed
+        internal int nextPending;  // index of next pending byte to output to the stream
+        internal int pendingCount; // number of bytes in the pending buffer
+
+        internal sbyte data_type;  // UNKNOWN, BINARY or ASCII
+        internal int last_flush;   // value of flush param for previous deflate call
+
+        internal int w_size;       // LZ77 window size (32K by default)
+        internal int w_bits;       // log2(w_size)  (8..16)
+        internal int w_mask;       // w_size - 1
+
+        //internal byte[] dictionary;
+        internal byte[] window;
+
+        // Sliding window. Input bytes are read into the second half of the window,
+        // and move to the first half later to keep a dictionary of at least wSize
+        // bytes. With this organization, matches are limited to a distance of
+        // wSize-MAX_MATCH bytes, but this ensures that IO is always
+        // performed with a length multiple of the block size.
+        //
+        // To do: use the user input buffer as sliding window.
+
+        internal int window_size;
+        // Actual size of window: 2*wSize, except when the user input buffer
+        // is directly used as sliding window.
+
+        internal short[] prev;
+        // Link to older string with same hash index. To limit the size of this
+        // array to 64K, this link is maintained only for the last 32K strings.
+        // An index in this array is thus a window index modulo 32K.
+
+        internal short[] head;  // Heads of the hash chains or NIL.
+
+        internal int ins_h;     // hash index of string to be inserted
+        internal int hash_size; // number of elements in hash table
+        internal int hash_bits; // log2(hash_size)
+        internal int hash_mask; // hash_size-1
+
+        // Number of bits by which ins_h must be shifted at each input
+        // step. It must be such that after MIN_MATCH steps, the oldest
+        // byte no longer takes part in the hash key, that is:
+        // hash_shift * MIN_MATCH >= hash_bits
+        internal int hash_shift;
+
+        // Window position at the beginning of the current output block. Gets
+        // negative when the window is moved backwards.
+
+        internal int block_start;
+
+        Config config;
+        internal int match_length;    // length of best match
+        internal int prev_match;      // previous match
+        internal int match_available; // set if previous match exists
+        internal int strstart;        // start of string to insert into.....????
+        internal int match_start;     // start of matching string
+        internal int lookahead;       // number of valid bytes ahead in window
+
+        // Length of the best match at previous step. Matches not greater than this
+        // are discarded. This is used in the lazy match evaluation.
+        internal int prev_length;
+
+        // Insert new strings in the hash table only if the match length is not
+        // greater than this length. This saves time but degrades compression.
+        // max_insert_length is used only for compression levels <= 3.
+
+        internal CompressionLevel compressionLevel; // compression level (1..9)
+        internal CompressionStrategy compressionStrategy; // favor or force Huffman coding
+
+
+        internal short[] dyn_ltree;         // literal and length tree
+        internal short[] dyn_dtree;         // distance tree
+        internal short[] bl_tree;           // Huffman tree for bit lengths
+
+        internal Tree treeLiterals = new Tree();  // desc for literal tree
+        internal Tree treeDistances = new Tree();  // desc for distance tree
+        internal Tree treeBitLengths = new Tree(); // desc for bit length tree
+
+        // number of codes at each bit length for an optimal tree
+        internal short[] bl_count = new short[InternalConstants.MAX_BITS + 1];
+
+        // heap used to build the Huffman trees
+        internal int[] heap = new int[2 * InternalConstants.L_CODES + 1];
+
+        internal int heap_len;              // number of elements in the heap
+        internal int heap_max;              // element of largest frequency
+
+        // The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+        // The same heap array is used to build all trees.
+
+        // Depth of each subtree used as tie breaker for trees of equal frequency
+        internal sbyte[] depth = new sbyte[2 * InternalConstants.L_CODES + 1];
+
+        internal int _lengthOffset;                 // index for literals or lengths
+
+
+        // Size of match buffer for literals/lengths.  There are 4 reasons for
+        // limiting lit_bufsize to 64K:
+        //   - frequencies can be kept in 16 bit counters
+        //   - if compression is not successful for the first block, all input
+        //     data is still in the window so we can still emit a stored block even
+        //     when input comes from standard input.  (This can also be done for
+        //     all blocks if lit_bufsize is not greater than 32K.)
+        //   - if compression is not successful for a file smaller than 64K, we can
+        //     even emit a stored file instead of a stored block (saving 5 bytes).
+        //     This is applicable only for zip (not gzip or zlib).
+        //   - creating new Huffman trees less frequently may not provide fast
+        //     adaptation to changes in the input data statistics. (Take for
+        //     example a binary file with poorly compressible code followed by
+        //     a highly compressible string table.) Smaller buffer sizes give
+        //     fast adaptation but have of course the overhead of transmitting
+        //     trees more frequently.
+
+        internal int lit_bufsize;
+
+        internal int last_lit;     // running index in l_buf
+
+        // Buffer for distances. To simplify the code, d_buf and l_buf have
+        // the same number of elements. To use different lengths, an extra flag
+        // array would be necessary.
+
+        internal int _distanceOffset;        // index into pending; points to distance data??
+
+        internal int opt_len;      // bit length of current block with optimal trees
+        internal int static_len;   // bit length of current block with static trees
+        internal int matches;      // number of string matches in current block
+        internal int last_eob_len; // bit length of EOB code for last block
+
+        // Output buffer. bits are inserted starting at the bottom (least
+        // significant bits).
+        internal short bi_buf;
+
+        // Number of valid bits in bi_buf.  All bits above the last valid bit
+        // are always zero.
+        internal int bi_valid;
+
+
+        internal DeflateManager()
+        {
+            dyn_ltree = new short[HEAP_SIZE * 2];
+            dyn_dtree = new short[(2 * InternalConstants.D_CODES + 1) * 2]; // distance tree
+            bl_tree = new short[(2 * InternalConstants.BL_CODES + 1) * 2]; // Huffman tree for bit lengths
+        }
+
+
+        // lm_init
+        private void _InitializeLazyMatch()
+        {
+            window_size = 2 * w_size;
+
+            // clear the hash - workitem 9063
+            Array.Clear(head, 0, hash_size);
+            //for (int i = 0; i < hash_size; i++) head[i] = 0;
+
+            config = Config.Lookup(compressionLevel);
+            SetDeflater();
+
+            strstart = 0;
+            block_start = 0;
+            lookahead = 0;
+            match_length = prev_length = MIN_MATCH - 1;
+            match_available = 0;
+            ins_h = 0;
+        }
+
+        // Initialize the tree data structures for a new zlib stream.
+        private void _InitializeTreeData()
+        {
+            treeLiterals.dyn_tree = dyn_ltree;
+            treeLiterals.staticTree = StaticTree.Literals;
+
+            treeDistances.dyn_tree = dyn_dtree;
+            treeDistances.staticTree = StaticTree.Distances;
+
+            treeBitLengths.dyn_tree = bl_tree;
+            treeBitLengths.staticTree = StaticTree.BitLengths;
+
+            bi_buf = 0;
+            bi_valid = 0;
+            last_eob_len = 8; // enough lookahead for inflate
+
+            // Initialize the first block of the first file:
+            _InitializeBlocks();
+        }
+
+        internal void _InitializeBlocks()
+        {
+            // Initialize the trees.
+            for (int i = 0; i < InternalConstants.L_CODES; i++)
+                dyn_ltree[i * 2] = 0;
+            for (int i = 0; i < InternalConstants.D_CODES; i++)
+                dyn_dtree[i * 2] = 0;
+            for (int i = 0; i < InternalConstants.BL_CODES; i++)
+                bl_tree[i * 2] = 0;
+
+            dyn_ltree[END_BLOCK * 2] = 1;
+            opt_len = static_len = 0;
+            last_lit = matches = 0;
+        }
+
+        // Restore the heap property by moving down the tree starting at node k,
+        // exchanging a node with the smallest of its two sons if necessary, stopping
+        // when the heap property is re-established (each father smaller than its
+        // two sons).
+        internal void pqdownheap(short[] tree, int k)
+        {
+            int v = heap[k];
+            int j = k << 1; // left son of k
+            while (j <= heap_len)
+            {
+                // Set j to the smallest of the two sons:
+                if (j < heap_len && _IsSmaller(tree, heap[j + 1], heap[j], depth))
+                {
+                    j++;
+                }
+                // Exit if v is smaller than both sons
+                if (_IsSmaller(tree, v, heap[j], depth))
+                    break;
+
+                // Exchange v with the smallest son
+                heap[k] = heap[j]; k = j;
+                // And continue down the tree, setting j to the left son of k
+                j <<= 1;
+            }
+            heap[k] = v;
+        }
+
+        internal static bool _IsSmaller(short[] tree, int n, int m, sbyte[] depth)
+        {
+            short tn2 = tree[n * 2];
+            short tm2 = tree[m * 2];
+            return (tn2 < tm2 || (tn2 == tm2 && depth[n] <= depth[m]));
+        }
+
+
+        // Scan a literal or distance tree to determine the frequencies of the codes
+        // in the bit length tree.
+        internal void scan_tree(short[] tree, int max_code)
+        {
+            int n; // iterates over all tree elements
+            int prevlen = -1; // last emitted length
+            int curlen; // length of current code
+            int nextlen = (int)tree[0 * 2 + 1]; // length of next code
+            int count = 0; // repeat count of the current code
+            int max_count = 7; // max repeat count
+            int min_count = 4; // min repeat count
+
+            if (nextlen == 0)
+            {
+                max_count = 138; min_count = 3;
+            }
+            tree[(max_code + 1) * 2 + 1] = (short)0x7fff; // guard //??
+
+            for (n = 0; n <= max_code; n++)
+            {
+                curlen = nextlen; nextlen = (int)tree[(n + 1) * 2 + 1];
+                if (++count < max_count && curlen == nextlen)
+                {
+                    continue;
+                }
+                else if (count < min_count)
+                {
+                    bl_tree[curlen * 2] = (short)(bl_tree[curlen * 2] + count);
+                }
+                else if (curlen != 0)
+                {
+                    if (curlen != prevlen)
+                        bl_tree[curlen * 2]++;
+                    bl_tree[InternalConstants.REP_3_6 * 2]++;
+                }
+                else if (count <= 10)
+                {
+                    bl_tree[InternalConstants.REPZ_3_10 * 2]++;
+                }
+                else
+                {
+                    bl_tree[InternalConstants.REPZ_11_138 * 2]++;
+                }
+                count = 0; prevlen = curlen;
+                if (nextlen == 0)
+                {
+                    max_count = 138; min_count = 3;
+                }
+                else if (curlen == nextlen)
+                {
+                    max_count = 6; min_count = 3;
+                }
+                else
+                {
+                    max_count = 7; min_count = 4;
+                }
+            }
+        }
+
+        // Construct the Huffman tree for the bit lengths and return the index in
+        // bl_order of the last bit length code to send.
+        internal int build_bl_tree()
+        {
+            int max_blindex; // index of last bit length code of non zero freq
+
+            // Determine the bit length frequencies for literal and distance trees
+            scan_tree(dyn_ltree, treeLiterals.max_code);
+            scan_tree(dyn_dtree, treeDistances.max_code);
+
+            // Build the bit length tree:
+            treeBitLengths.build_tree(this);
+            // opt_len now includes the length of the tree representations, except
+            // the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
+
+            // Determine the number of bit length codes to send. The pkzip format
+            // requires that at least 4 bit length codes be sent. (appnote.txt says
+            // 3 but the actual value used is 4.)
+            for (max_blindex = InternalConstants.BL_CODES - 1; max_blindex >= 3; max_blindex--)
+            {
+                if (bl_tree[Tree.bl_order[max_blindex] * 2 + 1] != 0)
+                    break;
+            }
+            // Update opt_len to include the bit length tree and counts
+            opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
+
+            return max_blindex;
+        }
+
+
+        // Send the header for a block using dynamic Huffman trees: the counts, the
+        // lengths of the bit length codes, the literal tree and the distance tree.
+        // IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+        internal void send_all_trees(int lcodes, int dcodes, int blcodes)
+        {
+            int rank; // index in bl_order
+
+            send_bits(lcodes - 257, 5); // not +255 as stated in appnote.txt
+            send_bits(dcodes - 1, 5);
+            send_bits(blcodes - 4, 4); // not -3 as stated in appnote.txt
+            for (rank = 0; rank < blcodes; rank++)
+            {
+                send_bits(bl_tree[Tree.bl_order[rank] * 2 + 1], 3);
+            }
+            send_tree(dyn_ltree, lcodes - 1); // literal tree
+            send_tree(dyn_dtree, dcodes - 1); // distance tree
+        }
+
+        // Send a literal or distance tree in compressed form, using the codes in
+        // bl_tree.
+        internal void send_tree(short[] tree, int max_code)
+        {
+            int n;                           // iterates over all tree elements
+            int prevlen = -1;              // last emitted length
+            int curlen;                      // length of current code
+            int nextlen = tree[0 * 2 + 1]; // length of next code
+            int count = 0;               // repeat count of the current code
+            int max_count = 7;               // max repeat count
+            int min_count = 4;               // min repeat count
+
+            if (nextlen == 0)
+            {
+                max_count = 138; min_count = 3;
+            }
+
+            for (n = 0; n <= max_code; n++)
+            {
+                curlen = nextlen; nextlen = tree[(n + 1) * 2 + 1];
+                if (++count < max_count && curlen == nextlen)
+                {
+                    continue;
+                }
+                else if (count < min_count)
+                {
+                    do
+                    {
+                        send_code(curlen, bl_tree);
+                    }
+                    while (--count != 0);
+                }
+                else if (curlen != 0)
+                {
+                    if (curlen != prevlen)
+                    {
+                        send_code(curlen, bl_tree); count--;
+                    }
+                    send_code(InternalConstants.REP_3_6, bl_tree);
+                    send_bits(count - 3, 2);
+                }
+                else if (count <= 10)
+                {
+                    send_code(InternalConstants.REPZ_3_10, bl_tree);
+                    send_bits(count - 3, 3);
+                }
+                else
+                {
+                    send_code(InternalConstants.REPZ_11_138, bl_tree);
+                    send_bits(count - 11, 7);
+                }
+                count = 0; prevlen = curlen;
+                if (nextlen == 0)
+                {
+                    max_count = 138; min_count = 3;
+                }
+                else if (curlen == nextlen)
+                {
+                    max_count = 6; min_count = 3;
+                }
+                else
+                {
+                    max_count = 7; min_count = 4;
+                }
+            }
+        }
+
+        // Output a block of bytes on the stream.
+        // IN assertion: there is enough room in pending_buf.
+        private void put_bytes(byte[] p, int start, int len)
+        {
+            Array.Copy(p, start, pending, pendingCount, len);
+            pendingCount += len;
+        }
+
+#if NOTNEEDED
+        private void put_byte(byte c)
+        {
+            pending[pendingCount++] = c;
+        }
+        internal void put_short(int b)
+        {
+            unchecked
+            {
+                pending[pendingCount++] = (byte)b;
+                pending[pendingCount++] = (byte)(b >> 8);
+            }
+        }
+        internal void putShortMSB(int b)
+        {
+            unchecked
+            {
+                pending[pendingCount++] = (byte)(b >> 8);
+                pending[pendingCount++] = (byte)b;
+            }
+        }
+#endif
+
+        internal void send_code(int c, short[] tree)
+        {
+            int c2 = c * 2;
+            send_bits((tree[c2] & 0xffff), (tree[c2 + 1] & 0xffff));
+        }
+
+        internal void send_bits(int value, int length)
+        {
+            int len = length;
+            unchecked
+            {
+                if (bi_valid > (int)Buf_size - len)
+                {
+                    //int val = value;
+                    //      bi_buf |= (val << bi_valid);
+
+                    bi_buf |= (short)((value << bi_valid) & 0xffff);
+                    //put_short(bi_buf);
+                    pending[pendingCount++] = (byte)bi_buf;
+                    pending[pendingCount++] = (byte)(bi_buf >> 8);
+
+
+                    bi_buf = (short)((uint)value >> (Buf_size - bi_valid));
+                    bi_valid += len - Buf_size;
+                }
+                else
+                {
+                    //      bi_buf |= (value) << bi_valid;
+                    bi_buf |= (short)((value << bi_valid) & 0xffff);
+                    bi_valid += len;
+                }
+            }
+        }
+
+        // Send one empty static block to give enough lookahead for inflate.
+        // This takes 10 bits, of which 7 may remain in the bit buffer.
+        // The current inflate code requires 9 bits of lookahead. If the
+        // last two codes for the previous block (real code plus EOB) were coded
+        // on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode
+        // the last real code. In this case we send two empty static blocks instead
+        // of one. (There are no problems if the previous block is stored or fixed.)
+        // To simplify the code, we assume the worst case of last real code encoded
+        // on one bit only.
+        internal void _tr_align()
+        {
+            send_bits(STATIC_TREES << 1, 3);
+            send_code(END_BLOCK, StaticTree.lengthAndLiteralsTreeCodes);
+
+            bi_flush();
+
+            // Of the 10 bits for the empty block, we have already sent
+            // (10 - bi_valid) bits. The lookahead for the last real code (before
+            // the EOB of the previous block) was thus at least one plus the length
+            // of the EOB plus what we have just sent of the empty static block.
+            if (1 + last_eob_len + 10 - bi_valid < 9)
+            {
+                send_bits(STATIC_TREES << 1, 3);
+                send_code(END_BLOCK, StaticTree.lengthAndLiteralsTreeCodes);
+                bi_flush();
+            }
+            last_eob_len = 7;
+        }
+
+
+        // Save the match info and tally the frequency counts. Return true if
+        // the current block must be flushed.
+        internal bool _tr_tally(int dist, int lc)
+        {
+            pending[_distanceOffset + last_lit * 2] = unchecked((byte)((uint)dist >> 8));
+            pending[_distanceOffset + last_lit * 2 + 1] = unchecked((byte)dist);
+            pending[_lengthOffset + last_lit] = unchecked((byte)lc);
+            last_lit++;
+
+            if (dist == 0)
+            {
+                // lc is the unmatched char
+                dyn_ltree[lc * 2]++;
+            }
+            else
+            {
+                matches++;
+                // Here, lc is the match length - MIN_MATCH
+                dist--; // dist = match distance - 1
+                dyn_ltree[(Tree.LengthCode[lc] + InternalConstants.LITERALS + 1) * 2]++;
+                dyn_dtree[Tree.DistanceCode(dist) * 2]++;
+            }
+
+            if ((last_lit & 0x1fff) == 0 && (int)compressionLevel > 2)
+            {
+                // Compute an upper bound for the compressed length
+                int out_length = last_lit << 3;
+                int in_length = strstart - block_start;
+                int dcode;
+                for (dcode = 0; dcode < InternalConstants.D_CODES; dcode++)
+                {
+                    out_length = (int)(out_length + (int)dyn_dtree[dcode * 2] * (5L + Tree.ExtraDistanceBits[dcode]));
+                }
+                out_length >>= 3;
+                if ((matches < (last_lit / 2)) && out_length < in_length / 2)
+                    return true;
+            }
+
+            return (last_lit == lit_bufsize - 1) || (last_lit == lit_bufsize);
+            // dinoch - wraparound?
+            // We avoid equality with lit_bufsize because of wraparound at 64K
+            // on 16 bit machines and because stored blocks are restricted to
+            // 64K-1 bytes.
+        }
+
+
+
+        // Send the block data compressed using the given Huffman trees
+        internal void send_compressed_block(short[] ltree, short[] dtree)
+        {
+            int distance; // distance of matched string
+            int lc;       // match length or unmatched char (if dist == 0)
+            int lx = 0;   // running index in l_buf
+            int code;     // the code to send
+            int extra;    // number of extra bits to send
+
+            if (last_lit != 0)
+            {
+                do
+                {
+                    int ix = _distanceOffset + lx * 2;
+                    distance = ((pending[ix] << 8) & 0xff00) |
+                        (pending[ix + 1] & 0xff);
+                    lc = (pending[_lengthOffset + lx]) & 0xff;
+                    lx++;
+
+                    if (distance == 0)
+                    {
+                        send_code(lc, ltree); // send a literal byte
+                    }
+                    else
+                    {
+                        // literal or match pair
+                        // Here, lc is the match length - MIN_MATCH
+                        code = Tree.LengthCode[lc];
+
+                        // send the length code
+                        send_code(code + InternalConstants.LITERALS + 1, ltree);
+                        extra = Tree.ExtraLengthBits[code];
+                        if (extra != 0)
+                        {
+                            // send the extra length bits
+                            lc -= Tree.LengthBase[code];
+                            send_bits(lc, extra);
+                        }
+                        distance--; // dist is now the match distance - 1
+                        code = Tree.DistanceCode(distance);
+
+                        // send the distance code
+                        send_code(code, dtree);
+
+                        extra = Tree.ExtraDistanceBits[code];
+                        if (extra != 0)
+                        {
+                            // send the extra distance bits
+                            distance -= Tree.DistanceBase[code];
+                            send_bits(distance, extra);
+                        }
+                    }
+
+                    // Check that the overlay between pending and d_buf+l_buf is ok:
+                }
+                while (lx < last_lit);
+            }
+
+            send_code(END_BLOCK, ltree);
+            last_eob_len = ltree[END_BLOCK * 2 + 1];
+        }
+
+
+
+        // Set the data type to ASCII or BINARY, using a crude approximation:
+        // binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise.
+        // IN assertion: the fields freq of dyn_ltree are set and the total of all
+        // frequencies does not exceed 64K (to fit in an int on 16 bit machines).
+        internal void set_data_type()
+        {
+            int n = 0;
+            int ascii_freq = 0;
+            int bin_freq = 0;
+            while (n < 7)
+            {
+                bin_freq += dyn_ltree[n * 2]; n++;
+            }
+            while (n < 128)
+            {
+                ascii_freq += dyn_ltree[n * 2]; n++;
+            }
+            while (n < InternalConstants.LITERALS)
+            {
+                bin_freq += dyn_ltree[n * 2]; n++;
+            }
+            data_type = (sbyte)(bin_freq > (ascii_freq >> 2) ? Z_BINARY : Z_ASCII);
+        }
+
+
+
+        // Flush the bit buffer, keeping at most 7 bits in it.
+        internal void bi_flush()
+        {
+            if (bi_valid == 16)
+            {
+                pending[pendingCount++] = (byte)bi_buf;
+                pending[pendingCount++] = (byte)(bi_buf >> 8);
+                bi_buf = 0;
+                bi_valid = 0;
+            }
+            else if (bi_valid >= 8)
+            {
+                //put_byte((byte)bi_buf);
+                pending[pendingCount++] = (byte)bi_buf;
+                bi_buf >>= 8;
+                bi_valid -= 8;
+            }
+        }
+
+        // Flush the bit buffer and align the output on a byte boundary
+        internal void bi_windup()
+        {
+            if (bi_valid > 8)
+            {
+                pending[pendingCount++] = (byte)bi_buf;
+                pending[pendingCount++] = (byte)(bi_buf >> 8);
+            }
+            else if (bi_valid > 0)
+            {
+                //put_byte((byte)bi_buf);
+                pending[pendingCount++] = (byte)bi_buf;
+            }
+            bi_buf = 0;
+            bi_valid = 0;
+        }
+
+        // Copy a stored block, storing first the length and its
+        // one's complement if requested.
+        internal void copy_block(int buf, int len, bool header)
+        {
+            bi_windup(); // align on byte boundary
+            last_eob_len = 8; // enough lookahead for inflate
+
+            if (header)
+                unchecked
+                {
+                    //put_short((short)len);
+                    pending[pendingCount++] = (byte)len;
+                    pending[pendingCount++] = (byte)(len >> 8);
+                    //put_short((short)~len);
+                    pending[pendingCount++] = (byte)~len;
+                    pending[pendingCount++] = (byte)(~len >> 8);
+                }
+
+            put_bytes(window, buf, len);
+        }
+
+        internal void flush_block_only(bool eof)
+        {
+            _tr_flush_block(block_start >= 0 ? block_start : -1, strstart - block_start, eof);
+            block_start = strstart;
+            _codec.flush_pending();
+        }
+
+        // Copy without compression as much as possible from the input stream, return
+        // the current block state.
+        // This function does not insert new strings in the dictionary since
+        // uncompressible data is probably not useful. This function is used
+        // only for the level=0 compression option.
+        // NOTE: this function should be optimized to avoid extra copying from
+        // window to pending_buf.
+        internal BlockState DeflateNone(FlushType flush)
+        {
+            // Stored blocks are limited to 0xffff bytes, pending is limited
+            // to pending_buf_size, and each stored block has a 5 byte header:
+
+            int max_block_size = 0xffff;
+            int max_start;
+
+            if (max_block_size > pending.Length - 5)
+            {
+                max_block_size = pending.Length - 5;
+            }
+
+            // Copy as much as possible from input to output:
+            while (true)
+            {
+                // Fill the window as much as possible:
+                if (lookahead <= 1)
+                {
+                    _fillWindow();
+                    if (lookahead == 0 && flush == FlushType.None)
+                        return BlockState.NeedMore;
+                    if (lookahead == 0)
+                        break; // flush the current block
+                }
+
+                strstart += lookahead;
+                lookahead = 0;
+
+                // Emit a stored block if pending will be full:
+                max_start = block_start + max_block_size;
+                if (strstart == 0 || strstart >= max_start)
+                {
+                    // strstart == 0 is possible when wraparound on 16-bit machine
+                    lookahead = (int)(strstart - max_start);
+                    strstart = (int)max_start;
+
+                    flush_block_only(false);
+                    if (_codec.AvailableBytesOut == 0)
+                        return BlockState.NeedMore;
+                }
+
+                // Flush if we may have to slide, otherwise block_start may become
+                // negative and the data will be gone:
+                if (strstart - block_start >= w_size - MIN_LOOKAHEAD)
+                {
+                    flush_block_only(false);
+                    if (_codec.AvailableBytesOut == 0)
+                        return BlockState.NeedMore;
+                }
+            }
+
+            flush_block_only(flush == FlushType.Finish);
+            if (_codec.AvailableBytesOut == 0)
+                return (flush == FlushType.Finish) ? BlockState.FinishStarted : BlockState.NeedMore;
+
+            return flush == FlushType.Finish ? BlockState.FinishDone : BlockState.BlockDone;
+        }
+
+
+        // Send a stored block
+        internal void _tr_stored_block(int buf, int stored_len, bool eof)
+        {
+            send_bits((STORED_BLOCK << 1) + (eof ? 1 : 0), 3); // send block type
+            copy_block(buf, stored_len, true); // with header
+        }
+
+        // Determine the best encoding for the current block: dynamic trees, static
+        // trees or store, and output the encoded block to the zip file.
+        internal void _tr_flush_block(int buf, int stored_len, bool eof)
+        {
+            int opt_lenb, static_lenb; // opt_len and static_len in bytes
+            int max_blindex = 0; // index of last bit length code of non zero freq
+
+            // Build the Huffman trees unless a stored block is forced
+            if (compressionLevel > 0)
+            {
+                // Check if the file is ascii or binary
+                if (data_type == Z_UNKNOWN)
+                    set_data_type();
+
+                // Construct the literal and distance trees
+                treeLiterals.build_tree(this);
+
+                treeDistances.build_tree(this);
+
+                // At this point, opt_len and static_len are the total bit lengths of
+                // the compressed block data, excluding the tree representations.
+
+                // Build the bit length tree for the above two trees, and get the index
+                // in bl_order of the last bit length code to send.
+                max_blindex = build_bl_tree();
+
+                // Determine the best encoding. Compute first the block length in bytes
+                opt_lenb = (opt_len + 3 + 7) >> 3;
+                static_lenb = (static_len + 3 + 7) >> 3;
+
+                if (static_lenb <= opt_lenb)
+                    opt_lenb = static_lenb;
+            }
+            else
+            {
+                opt_lenb = static_lenb = stored_len + 5; // force a stored block
+            }
+
+            if (stored_len + 4 <= opt_lenb && buf != -1)
+            {
+                // 4: two words for the lengths
+                // The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
+                // Otherwise we can't have processed more than WSIZE input bytes since
+                // the last block flush, because compression would have been
+                // successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
+                // transform a block into a stored block.
+                _tr_stored_block(buf, stored_len, eof);
+            }
+            else if (static_lenb == opt_lenb)
+            {
+                send_bits((STATIC_TREES << 1) + (eof ? 1 : 0), 3);
+                send_compressed_block(StaticTree.lengthAndLiteralsTreeCodes, StaticTree.distTreeCodes);
+            }
+            else
+            {
+                send_bits((DYN_TREES << 1) + (eof ? 1 : 0), 3);
+                send_all_trees(treeLiterals.max_code + 1, treeDistances.max_code + 1, max_blindex + 1);
+                send_compressed_block(dyn_ltree, dyn_dtree);
+            }
+
+            // The above check is made mod 2^32, for files larger than 512 MB
+            // and uLong implemented on 32 bits.
+
+            _InitializeBlocks();
+
+            if (eof)
+            {
+                bi_windup();
+            }
+        }
+
+        // Fill the window when the lookahead becomes insufficient.
+        // Updates strstart and lookahead.
+        //
+        // IN assertion: lookahead < MIN_LOOKAHEAD
+        // OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
+        //    At least one byte has been read, or avail_in == 0; reads are
+        //    performed for at least two bytes (required for the zip translate_eol
+        //    option -- not supported here).
+        private void _fillWindow()
+        {
+            int n, m;
+            int p;
+            int more; // Amount of free space at the end of the window.
+
+            do
+            {
+                more = (window_size - lookahead - strstart);
+
+                // Deal with !@#$% 64K limit:
+                if (more == 0 && strstart == 0 && lookahead == 0)
+                {
+                    more = w_size;
+                }
+                else if (more == -1)
+                {
+                    // Very unlikely, but possible on 16 bit machine if strstart == 0
+                    // and lookahead == 1 (input done one byte at time)
+                    more--;
+
+                    // If the window is almost full and there is insufficient lookahead,
+                    // move the upper half to the lower one to make room in the upper half.
+                }
+                else if (strstart >= w_size + w_size - MIN_LOOKAHEAD)
+                {
+                    Array.Copy(window, w_size, window, 0, w_size);
+                    match_start -= w_size;
+                    strstart -= w_size; // we now have strstart >= MAX_DIST
+                    block_start -= w_size;
+
+                    // Slide the hash table (could be avoided with 32 bit values
+                    // at the expense of memory usage). We slide even when level == 0
+                    // to keep the hash table consistent if we switch back to level > 0
+                    // later. (Using level 0 permanently is not an optimal usage of
+                    // zlib, so we don't care about this pathological case.)
+
+                    n = hash_size;
+                    p = n;
+                    do
+                    {
+                        m = (head[--p] & 0xffff);
+                        head[p] = (short)((m >= w_size) ? (m - w_size) : 0);
+                    }
+                    while (--n != 0);
+
+                    n = w_size;
+                    p = n;
+                    do
+                    {
+                        m = (prev[--p] & 0xffff);
+                        prev[p] = (short)((m >= w_size) ? (m - w_size) : 0);
+                        // If n is not on any hash chain, prev[n] is garbage but
+                        // its value will never be used.
+                    }
+                    while (--n != 0);
+                    more += w_size;
+                }
+
+                if (_codec.AvailableBytesIn == 0)
+                    return;
+
+                // If there was no sliding:
+                //    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
+                //    more == window_size - lookahead - strstart
+                // => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
+                // => more >= window_size - 2*WSIZE + 2
+                // In the BIG_MEM or MMAP case (not yet supported),
+                //   window_size == input_size + MIN_LOOKAHEAD  &&
+                //   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
+                // Otherwise, window_size == 2*WSIZE so more >= 2.
+                // If there was sliding, more >= WSIZE. So in all cases, more >= 2.
+
+                n = _codec.read_buf(window, strstart + lookahead, more);
+                lookahead += n;
+
+                // Initialize the hash value now that we have some input:
+                if (lookahead >= MIN_MATCH)
+                {
+                    ins_h = window[strstart] & 0xff;
+                    ins_h = (((ins_h) << hash_shift) ^ (window[strstart + 1] & 0xff)) & hash_mask;
+                }
+                // If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
+                // but this is not important since only literal bytes will be emitted.
+            }
+            while (lookahead < MIN_LOOKAHEAD && _codec.AvailableBytesIn != 0);
+        }
+
+        // Compress as much as possible from the input stream, return the current
+        // block state.
+        // This function does not perform lazy evaluation of matches and inserts
+        // new strings in the dictionary only for unmatched strings or for short
+        // matches. It is used only for the fast compression options.
+        internal BlockState DeflateFast(FlushType flush)
+        {
+            //    short hash_head = 0; // head of the hash chain
+            int hash_head = 0; // head of the hash chain
+            bool bflush; // set if current block must be flushed
+
+            while (true)
+            {
+                // Make sure that we always have enough lookahead, except
+                // at the end of the input file. We need MAX_MATCH bytes
+                // for the next match, plus MIN_MATCH bytes to insert the
+                // string following the next match.
+                if (lookahead < MIN_LOOKAHEAD)
+                {
+                    _fillWindow();
+                    if (lookahead < MIN_LOOKAHEAD && flush == FlushType.None)
+                    {
+                        return BlockState.NeedMore;
+                    }
+                    if (lookahead == 0)
+                        break; // flush the current block
+                }
+
+                // Insert the string window[strstart .. strstart+2] in the
+                // dictionary, and set hash_head to the head of the hash chain:
+                if (lookahead >= MIN_MATCH)
+                {
+                    ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+
+                    //  prev[strstart&w_mask]=hash_head=head[ins_h];
+                    hash_head = (head[ins_h] & 0xffff);
+                    prev[strstart & w_mask] = head[ins_h];
+                    head[ins_h] = unchecked((short)strstart);
+                }
+
+                // Find the longest match, discarding those <= prev_length.
+                // At this point we have always match_length < MIN_MATCH
+
+                if (hash_head != 0L && ((strstart - hash_head) & 0xffff) <= w_size - MIN_LOOKAHEAD)
+                {
+                    // To simplify the code, we prevent matches with the string
+                    // of window index 0 (in particular we have to avoid a match
+                    // of the string with itself at the start of the input file).
+                    if (compressionStrategy != CompressionStrategy.HuffmanOnly)
+                    {
+                        match_length = longest_match(hash_head);
+                    }
+                    // longest_match() sets match_start
+                }
+                if (match_length >= MIN_MATCH)
+                {
+                    //        check_match(strstart, match_start, match_length);
+
+                    bflush = _tr_tally(strstart - match_start, match_length - MIN_MATCH);
+
+                    lookahead -= match_length;
+
+                    // Insert new strings in the hash table only if the match length
+                    // is not too large. This saves time but degrades compression.
+                    if (match_length <= config.MaxLazy && lookahead >= MIN_MATCH)
+                    {
+                        match_length--; // string at strstart already in hash table
+                        do
+                        {
+                            strstart++;
+
+                            ins_h = ((ins_h << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+                            //      prev[strstart&w_mask]=hash_head=head[ins_h];
+                            hash_head = (head[ins_h] & 0xffff);
+                            prev[strstart & w_mask] = head[ins_h];
+                            head[ins_h] = unchecked((short)strstart);
+
+                            // strstart never exceeds WSIZE-MAX_MATCH, so there are
+                            // always MIN_MATCH bytes ahead.
+                        }
+                        while (--match_length != 0);
+                        strstart++;
+                    }
+                    else
+                    {
+                        strstart += match_length;
+                        match_length = 0;
+                        ins_h = window[strstart] & 0xff;
+
+                        ins_h = (((ins_h) << hash_shift) ^ (window[strstart + 1] & 0xff)) & hash_mask;
+                        // If lookahead < MIN_MATCH, ins_h is garbage, but it does not
+                        // matter since it will be recomputed at next deflate call.
+                    }
+                }
+                else
+                {
+                    // No match, output a literal byte
+
+                    bflush = _tr_tally(0, window[strstart] & 0xff);
+                    lookahead--;
+                    strstart++;
+                }
+                if (bflush)
+                {
+                    flush_block_only(false);
+                    if (_codec.AvailableBytesOut == 0)
+                        return BlockState.NeedMore;
+                }
+            }
+
+            flush_block_only(flush == FlushType.Finish);
+            if (_codec.AvailableBytesOut == 0)
+            {
+                if (flush == FlushType.Finish)
+                    return BlockState.FinishStarted;
+                else
+                    return BlockState.NeedMore;
+            }
+            return flush == FlushType.Finish ? BlockState.FinishDone : BlockState.BlockDone;
+        }
+
+        // Same as above, but achieves better compression. We use a lazy
+        // evaluation for matches: a match is finally adopted only if there is
+        // no better match at the next window position.
+        internal BlockState DeflateSlow(FlushType flush)
+        {
+            //    short hash_head = 0;    // head of hash chain
+            int hash_head = 0; // head of hash chain
+            bool bflush; // set if current block must be flushed
+
+            // Process the input block.
+            while (true)
+            {
+                // Make sure that we always have enough lookahead, except
+                // at the end of the input file. We need MAX_MATCH bytes
+                // for the next match, plus MIN_MATCH bytes to insert the
+                // string following the next match.
+
+                if (lookahead < MIN_LOOKAHEAD)
+                {
+                    _fillWindow();
+                    if (lookahead < MIN_LOOKAHEAD && flush == FlushType.None)
+                        return BlockState.NeedMore;
+
+                    if (lookahead == 0)
+                        break; // flush the current block
+                }
+
+                // Insert the string window[strstart .. strstart+2] in the
+                // dictionary, and set hash_head to the head of the hash chain:
+
+                if (lookahead >= MIN_MATCH)
+                {
+                    ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+                    //  prev[strstart&w_mask]=hash_head=head[ins_h];
+                    hash_head = (head[ins_h] & 0xffff);
+                    prev[strstart & w_mask] = head[ins_h];
+                    head[ins_h] = unchecked((short)strstart);
+                }
+
+                // Find the longest match, discarding those <= prev_length.
+                prev_length = match_length;
+                prev_match = match_start;
+                match_length = MIN_MATCH - 1;
+
+                if (hash_head != 0 && prev_length < config.MaxLazy &&
+                    ((strstart - hash_head) & 0xffff) <= w_size - MIN_LOOKAHEAD)
+                {
+                    // To simplify the code, we prevent matches with the string
+                    // of window index 0 (in particular we have to avoid a match
+                    // of the string with itself at the start of the input file).
+
+                    if (compressionStrategy != CompressionStrategy.HuffmanOnly)
+                    {
+                        match_length = longest_match(hash_head);
+                    }
+                    // longest_match() sets match_start
+
+                    if (match_length <= 5 && (compressionStrategy == CompressionStrategy.Filtered ||
+                                              (match_length == MIN_MATCH && strstart - match_start > 4096)))
+                    {
+
+                        // If prev_match is also MIN_MATCH, match_start is garbage
+                        // but we will ignore the current match anyway.
+                        match_length = MIN_MATCH - 1;
+                    }
+                }
+
+                // If there was a match at the previous step and the current
+                // match is not better, output the previous match:
+                if (prev_length >= MIN_MATCH && match_length <= prev_length)
+                {
+                    int max_insert = strstart + lookahead - MIN_MATCH;
+                    // Do not insert strings in hash table beyond this.
+
+                    //          check_match(strstart-1, prev_match, prev_length);
+
+                    bflush = _tr_tally(strstart - 1 - prev_match, prev_length - MIN_MATCH);
+
+                    // Insert in hash table all strings up to the end of the match.
+                    // strstart-1 and strstart are already inserted. If there is not
+                    // enough lookahead, the last two strings are not inserted in
+                    // the hash table.
+                    lookahead -= (prev_length - 1);
+                    prev_length -= 2;
+                    do
+                    {
+                        if (++strstart <= max_insert)
+                        {
+                            ins_h = (((ins_h) << hash_shift) ^ (window[(strstart) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+                            //prev[strstart&w_mask]=hash_head=head[ins_h];
+                            hash_head = (head[ins_h] & 0xffff);
+                            prev[strstart & w_mask] = head[ins_h];
+                            head[ins_h] = unchecked((short)strstart);
+                        }
+                    }
+                    while (--prev_length != 0);
+                    match_available = 0;
+                    match_length = MIN_MATCH - 1;
+                    strstart++;
+
+                    if (bflush)
+                    {
+                        flush_block_only(false);
+                        if (_codec.AvailableBytesOut == 0)
+                            return BlockState.NeedMore;
+                    }
+                }
+                else if (match_available != 0)
+                {
+
+                    // If there was no match at the previous position, output a
+                    // single literal. If there was a match but the current match
+                    // is longer, truncate the previous match to a single literal.
+
+                    bflush = _tr_tally(0, window[strstart - 1] & 0xff);
+
+                    if (bflush)
+                    {
+                        flush_block_only(false);
+                    }
+                    strstart++;
+                    lookahead--;
+                    if (_codec.AvailableBytesOut == 0)
+                        return BlockState.NeedMore;
+                }
+                else
+                {
+                    // There is no previous match to compare with, wait for
+                    // the next step to decide.
+
+                    match_available = 1;
+                    strstart++;
+                    lookahead--;
+                }
+            }
+
+            if (match_available != 0)
+            {
+                bflush = _tr_tally(0, window[strstart - 1] & 0xff);
+                match_available = 0;
+            }
+            flush_block_only(flush == FlushType.Finish);
+
+            if (_codec.AvailableBytesOut == 0)
+            {
+                if (flush == FlushType.Finish)
+                    return BlockState.FinishStarted;
+                else
+                    return BlockState.NeedMore;
+            }
+
+            return flush == FlushType.Finish ? BlockState.FinishDone : BlockState.BlockDone;
+        }
+
+
+        internal int longest_match(int cur_match)
+        {
+            int chain_length = config.MaxChainLength; // max hash chain length
+            int scan = strstart;              // current string
+            int match;                                // matched string
+            int len;                                  // length of current match
+            int best_len = prev_length;           // best match length so far
+            int limit = strstart > (w_size - MIN_LOOKAHEAD) ? strstart - (w_size - MIN_LOOKAHEAD) : 0;
+
+            int niceLength = config.NiceLength;
+
+            // Stop when cur_match becomes <= limit. To simplify the code,
+            // we prevent matches with the string of window index 0.
+
+            int wmask = w_mask;
+
+            int strend = strstart + MAX_MATCH;
+            byte scan_end1 = window[scan + best_len - 1];
+            byte scan_end = window[scan + best_len];
+
+            // The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+            // It is easy to get rid of this optimization if necessary.
+
+            // Do not waste too much time if we already have a good match:
+            if (prev_length >= config.GoodLength)
+            {
+                chain_length >>= 2;
+            }
+
+            // Do not look for matches beyond the end of the input. This is necessary
+            // to make deflate deterministic.
+            if (niceLength > lookahead)
+                niceLength = lookahead;
+
+            do
+            {
+                match = cur_match;
+
+                // Skip to next match if the match length cannot increase
+                // or if the match length is less than 2:
+                if (window[match + best_len] != scan_end ||
+                    window[match + best_len - 1] != scan_end1 ||
+                    window[match] != window[scan] ||
+                    window[++match] != window[scan + 1])
+                    continue;
+
+                // The check at best_len-1 can be removed because it will be made
+                // again later. (This heuristic is not always a win.)
+                // It is not necessary to compare scan[2] and match[2] since they
+                // are always equal when the other bytes match, given that
+                // the hash keys are equal and that HASH_BITS >= 8.
+                scan += 2; match++;
+
+                // We check for insufficient lookahead only every 8th comparison;
+                // the 256th check will be made at strstart+258.
+                do
+                {
+                }
+                while (window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] &&
+                       window[++scan] == window[++match] && scan < strend);
+
+                len = MAX_MATCH - (int)(strend - scan);
+                scan = strend - MAX_MATCH;
+
+                if (len > best_len)
+                {
+                    match_start = cur_match;
+                    best_len = len;
+                    if (len >= niceLength)
+                        break;
+                    scan_end1 = window[scan + best_len - 1];
+                    scan_end = window[scan + best_len];
+                }
+            }
+            while ((cur_match = (prev[cur_match & wmask] & 0xffff)) > limit && --chain_length != 0);
+
+            if (best_len <= lookahead)
+                return best_len;
+            return lookahead;
+        }
+
+
+        private bool Rfc1950BytesEmitted = false;
+        private bool _WantRfc1950HeaderBytes = true;
+        internal bool WantRfc1950HeaderBytes
+        {
+            get { return _WantRfc1950HeaderBytes; }
+            set { _WantRfc1950HeaderBytes = value; }
+        }
+
+
+        internal int Initialize(ZlibCodec codec, CompressionLevel level)
+        {
+            return Initialize(codec, level, ZlibConstants.WindowBitsMax);
+        }
+
+        internal int Initialize(ZlibCodec codec, CompressionLevel level, int bits)
+        {
+            return Initialize(codec, level, bits, MEM_LEVEL_DEFAULT, CompressionStrategy.Default);
+        }
+
+        internal int Initialize(ZlibCodec codec, CompressionLevel level, int bits, CompressionStrategy compressionStrategy)
+        {
+            return Initialize(codec, level, bits, MEM_LEVEL_DEFAULT, compressionStrategy);
+        }
+
+        internal int Initialize(ZlibCodec codec, CompressionLevel level, int windowBits, int memLevel, CompressionStrategy strategy)
+        {
+            _codec = codec;
+            _codec.Message = null;
+
+            // validation
+            if (windowBits < 9 || windowBits > 15)
+                throw new ZlibException("windowBits must be in the range 9..15.");
+
+            if (memLevel < 1 || memLevel > MEM_LEVEL_MAX)
+                throw new ZlibException(String.Format("memLevel must be in the range 1.. {0}", MEM_LEVEL_MAX));
+
+            _codec.dstate = this;
+
+            w_bits = windowBits;
+            w_size = 1 << w_bits;
+            w_mask = w_size - 1;
+
+            hash_bits = memLevel + 7;
+            hash_size = 1 << hash_bits;
+            hash_mask = hash_size - 1;
+            hash_shift = ((hash_bits + MIN_MATCH - 1) / MIN_MATCH);
+
+            window = new byte[w_size * 2];
+            prev = new short[w_size];
+            head = new short[hash_size];
+
+            // for memLevel==8, this will be 16384, 16k
+            lit_bufsize = 1 << (memLevel + 6);
+
+            // Use a single array as the buffer for data pending compression,
+            // the output distance codes, and the output length codes (aka tree).
+            // orig comment: This works just fine since the average
+            // output size for (length,distance) codes is <= 24 bits.
+            pending = new byte[lit_bufsize * 4];
+            _distanceOffset = lit_bufsize;
+            _lengthOffset = (1 + 2) * lit_bufsize;
+
+            // So, for memLevel 8, the length of the pending buffer is 65536. 64k.
+            // The first 16k are pending bytes.
+            // The middle slice, of 32k, is used for distance codes.
+            // The final 16k are length codes.
+
+            this.compressionLevel = level;
+            this.compressionStrategy = strategy;
+
+            Reset();
+            return ZlibConstants.Z_OK;
+        }
+
+
+        internal void Reset()
+        {
+            _codec.TotalBytesIn = _codec.TotalBytesOut = 0;
+            _codec.Message = null;
+            //strm.data_type = Z_UNKNOWN;
+
+            pendingCount = 0;
+            nextPending = 0;
+
+            Rfc1950BytesEmitted = false;
+
+            status = (WantRfc1950HeaderBytes) ? INIT_STATE : BUSY_STATE;
+            _codec._Adler32 = Adler.Adler32(0, null, 0, 0);
+
+            last_flush = (int)FlushType.None;
+
+            _InitializeTreeData();
+            _InitializeLazyMatch();
+        }
+
+
+        internal int End()
+        {
+            if (status != INIT_STATE && status != BUSY_STATE && status != FINISH_STATE)
+            {
+                return ZlibConstants.Z_STREAM_ERROR;
+            }
+            // Deallocate in reverse order of allocations:
+            pending = null;
+            head = null;
+            prev = null;
+            window = null;
+            // free
+            // dstate=null;
+            return status == BUSY_STATE ? ZlibConstants.Z_DATA_ERROR : ZlibConstants.Z_OK;
+        }
+
+
+        private void SetDeflater()
+        {
+            switch (config.Flavor)
+            {
+                case DeflateFlavor.Store:
+                    DeflateFunction = DeflateNone;
+                    break;
+                case DeflateFlavor.Fast:
+                    DeflateFunction = DeflateFast;
+                    break;
+                case DeflateFlavor.Slow:
+                    DeflateFunction = DeflateSlow;
+                    break;
+            }
+        }
+
+
+        internal int SetParams(CompressionLevel level, CompressionStrategy strategy)
+        {
+            int result = ZlibConstants.Z_OK;
+
+            if (compressionLevel != level)
+            {
+                Config newConfig = Config.Lookup(level);
+
+                // change in the deflate flavor (Fast vs slow vs none)?
+                if (newConfig.Flavor != config.Flavor && _codec.TotalBytesIn != 0)
+                {
+                    // Flush the last buffer:
+                    result = _codec.Deflate(FlushType.Partial);
+                }
+
+                compressionLevel = level;
+                config = newConfig;
+                SetDeflater();
+            }
+
+            // no need to flush with change in strategy?  Really?
+            compressionStrategy = strategy;
+
+            return result;
+        }
+
+
+        internal int SetDictionary(byte[] dictionary)
+        {
+            if (dictionary == null || status != INIT_STATE)
+                throw new ZlibException("Stream error.");
+
+            int length = dictionary.Length;
+            int index = 0;
+
+            _codec._Adler32 = Adler.Adler32(_codec._Adler32, dictionary, 0, dictionary.Length);
+
+            if (length < MIN_MATCH)
+                return ZlibConstants.Z_OK;
+            if (length > w_size - MIN_LOOKAHEAD)
+            {
+                length = w_size - MIN_LOOKAHEAD;
+                index = dictionary.Length - length; // use the tail of the dictionary
+            }
+            Array.Copy(dictionary, index, window, 0, length);
+            strstart = length;
+            block_start = length;
+
+            // Insert all strings in the hash table (except for the last two bytes).
+            // s->lookahead stays null, so s->ins_h will be recomputed at the next
+            // call of fill_window.
+
+            ins_h = window[0] & 0xff;
+            ins_h = (((ins_h) << hash_shift) ^ (window[1] & 0xff)) & hash_mask;
+
+            for (int n = 0; n <= length - MIN_MATCH; n++)
+            {
+                ins_h = (((ins_h) << hash_shift) ^ (window[(n) + (MIN_MATCH - 1)] & 0xff)) & hash_mask;
+                prev[n & w_mask] = head[ins_h];
+                head[ins_h] = (short)n;
+            }
+            return ZlibConstants.Z_OK;
+        }
+
+
+
+        internal int Deflate(FlushType flush)
+        {
+            int old_flush;
+
+            if (_codec.OutputBuffer == null ||
+                (_codec.InputBuffer == null && _codec.AvailableBytesIn != 0) ||
+                (status == FINISH_STATE && flush != FlushType.Finish))
+            {
+                _codec.Message = _ErrorMessage[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_STREAM_ERROR)];
+                throw new ZlibException(String.Format("Something is fishy. [{0}]", _codec.Message));
+            }
+            if (_codec.AvailableBytesOut == 0)
+            {
+                _codec.Message = _ErrorMessage[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_BUF_ERROR)];
+                throw new ZlibException("OutputBuffer is full (AvailableBytesOut == 0)");
+            }
+
+            old_flush = last_flush;
+            last_flush = (int)flush;
+
+            // Write the zlib (rfc1950) header bytes
+            if (status == INIT_STATE)
+            {
+                int header = (Z_DEFLATED + ((w_bits - 8) << 4)) << 8;
+                int level_flags = (((int)compressionLevel - 1) & 0xff) >> 1;
+
+                if (level_flags > 3)
+                    level_flags = 3;
+                header |= (level_flags << 6);
+                if (strstart != 0)
+                    header |= PRESET_DICT;
+                header += 31 - (header % 31);
+
+                status = BUSY_STATE;
+                //putShortMSB(header);
+                unchecked
+                {
+                    pending[pendingCount++] = (byte)(header >> 8);
+                    pending[pendingCount++] = (byte)header;
+                }
+                // Save the adler32 of the preset dictionary:
+                if (strstart != 0)
+                {
+                    pending[pendingCount++] = (byte)((_codec._Adler32 & 0xFF000000) >> 24);
+                    pending[pendingCount++] = (byte)((_codec._Adler32 & 0x00FF0000) >> 16);
+                    pending[pendingCount++] = (byte)((_codec._Adler32 & 0x0000FF00) >> 8);
+                    pending[pendingCount++] = (byte)(_codec._Adler32 & 0x000000FF);
+                }
+                _codec._Adler32 = Adler.Adler32(0, null, 0, 0);
+            }
+
+            // Flush as much pending output as possible
+            if (pendingCount != 0)
+            {
+                _codec.flush_pending();
+                if (_codec.AvailableBytesOut == 0)
+                {
+                    //System.out.println("  avail_out==0");
+                    // Since avail_out is 0, deflate will be called again with
+                    // more output space, but possibly with both pending and
+                    // avail_in equal to zero. There won't be anything to do,
+                    // but this is not an error situation so make sure we
+                    // return OK instead of BUF_ERROR at next call of deflate:
+                    last_flush = -1;
+                    return ZlibConstants.Z_OK;
+                }
+
+                // Make sure there is something to do and avoid duplicate consecutive
+                // flushes. For repeated and useless calls with Z_FINISH, we keep
+                // returning Z_STREAM_END instead of Z_BUFF_ERROR.
+            }
+            else if (_codec.AvailableBytesIn == 0 &&
+                     (int)flush <= old_flush &&
+                     flush != FlushType.Finish)
+            {
+                // workitem 8557
+                //
+                // Not sure why this needs to be an error.  pendingCount == 0, which
+                // means there's nothing to deflate.  And the caller has not asked
+                // for a FlushType.Finish, but...  that seems very non-fatal.  We
+                // can just say "OK" and do nothing.
+
+                // _codec.Message = z_errmsg[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_BUF_ERROR)];
+                // throw new ZlibException("AvailableBytesIn == 0 && flush<=old_flush && flush != FlushType.Finish");
+
+                return ZlibConstants.Z_OK;
+            }
+
+            // User must not provide more input after the first FINISH:
+            if (status == FINISH_STATE && _codec.AvailableBytesIn != 0)
+            {
+                _codec.Message = _ErrorMessage[ZlibConstants.Z_NEED_DICT - (ZlibConstants.Z_BUF_ERROR)];
+                throw new ZlibException("status == FINISH_STATE && _codec.AvailableBytesIn != 0");
+            }
+
+            // Start a new block or continue the current one.
+            if (_codec.AvailableBytesIn != 0 || lookahead != 0 || (flush != FlushType.None && status != FINISH_STATE))
+            {
+                BlockState bstate = DeflateFunction(flush);
+
+                if (bstate == BlockState.FinishStarted || bstate == BlockState.FinishDone)
+                {
+                    status = FINISH_STATE;
+                }
+                if (bstate == BlockState.NeedMore || bstate == BlockState.FinishStarted)
+                {
+                    if (_codec.AvailableBytesOut == 0)
+                    {
+                        last_flush = -1; // avoid BUF_ERROR next call, see above
+                    }
+                    return ZlibConstants.Z_OK;
+                    // If flush != Z_NO_FLUSH && avail_out == 0, the next call
+                    // of deflate should use the same flush parameter to make sure
+                    // that the flush is complete. So we don't have to output an
+                    // empty block here, this will be done at next call. This also
+                    // ensures that for a very small output buffer, we emit at most
+                    // one empty block.
+                }
+
+                if (bstate == BlockState.BlockDone)
+                {
+                    if (flush == FlushType.Partial)
+                    {
+                        _tr_align();
+                    }
+                    else
+                    {
+                        // FlushType.Full or FlushType.Sync
+                        _tr_stored_block(0, 0, false);
+                        // For a full flush, this empty block will be recognized
+                        // as a special marker by inflate_sync().
+                        if (flush == FlushType.Full)
+                        {
+                            // clear hash (forget the history)
+                            for (int i = 0; i < hash_size; i++)
+                                head[i] = 0;
+                        }
+                    }
+                    _codec.flush_pending();
+                    if (_codec.AvailableBytesOut == 0)
+                    {
+                        last_flush = -1; // avoid BUF_ERROR at next call, see above
+                        return ZlibConstants.Z_OK;
+                    }
+                }
+            }
+
+            if (flush != FlushType.Finish)
+                return ZlibConstants.Z_OK;
+
+            if (!WantRfc1950HeaderBytes || Rfc1950BytesEmitted)
+                return ZlibConstants.Z_STREAM_END;
+
+            // Write the zlib trailer (adler32)
+            pending[pendingCount++] = (byte)((_codec._Adler32 & 0xFF000000) >> 24);
+            pending[pendingCount++] = (byte)((_codec._Adler32 & 0x00FF0000) >> 16);
+            pending[pendingCount++] = (byte)((_codec._Adler32 & 0x0000FF00) >> 8);
+            pending[pendingCount++] = (byte)(_codec._Adler32 & 0x000000FF);
+            //putShortMSB((int)(SharedUtils.URShift(_codec._Adler32, 16)));
+            //putShortMSB((int)(_codec._Adler32 & 0xffff));
+
+            _codec.flush_pending();
+
+            // If avail_out is zero, the application will call deflate again
+            // to flush the rest.
+
+            Rfc1950BytesEmitted = true; // write the trailer only once!
+
+            return pendingCount != 0 ? ZlibConstants.Z_OK : ZlibConstants.Z_STREAM_END;
+        }
+
+    }
+
+    /// <summary>
+    ///   Computes a CRC-32. The CRC-32 algorithm is parameterized - you
+    ///   can set the polynomial and enable or disable bit
+    ///   reversal. This can be used for GZIP, BZip2, or ZIP.
+    /// </summary>
+    /// <remarks>
+    ///   This type is used internally by DotNetZip; it is generally not used
+    ///   directly by applications wishing to create, read, or manipulate zip
+    ///   archive files.
+    /// </remarks>
+
+    internal class CRC32
+    {
+        /// <summary>
+        ///   Indicates the total number of bytes applied to the CRC.
+        /// </summary>
+        internal Int64 TotalBytesRead
+        {
+            get
+            {
+                return _TotalBytesRead;
+            }
+        }
+
+        /// <summary>
+        /// Indicates the current CRC for all blocks slurped in.
+        /// </summary>
+        internal Int32 Crc32Result
+        {
+            get
+            {
+                return unchecked((Int32)(~_register));
+            }
+        }
+
+        /// <summary>
+        /// Returns the CRC32 for the specified stream.
+        /// </summary>
+        /// <param name="input">The stream over which to calculate the CRC32</param>
+        /// <returns>the CRC32 calculation</returns>
+        internal Int32 GetCrc32(System.IO.Stream input)
+        {
+            return GetCrc32AndCopy(input, null);
+        }
+
+        /// <summary>
+        /// Returns the CRC32 for the specified stream, and writes the input into the
+        /// output stream.
+        /// </summary>
+        /// <param name="input">The stream over which to calculate the CRC32</param>
+        /// <param name="output">The stream into which to deflate the input</param>
+        /// <returns>the CRC32 calculation</returns>
+        internal Int32 GetCrc32AndCopy(System.IO.Stream input, System.IO.Stream output)
+        {
+            if (input == null)
+                throw new Exception("The input stream must not be null.");
+
+            unchecked
+            {
+                byte[] buffer = new byte[BUFFER_SIZE];
+                int readSize = BUFFER_SIZE;
+
+                _TotalBytesRead = 0;
+                int count = input.Read(buffer, 0, readSize);
+                if (output != null) output.Write(buffer, 0, count);
+                _TotalBytesRead += count;
+                while (count > 0)
+                {
+                    SlurpBlock(buffer, 0, count);
+                    count = input.Read(buffer, 0, readSize);
+                    if (output != null) output.Write(buffer, 0, count);
+                    _TotalBytesRead += count;
+                }
+
+                return (Int32)(~_register);
+            }
+        }
+
+
+        /// <summary>
+        ///   Get the CRC32 for the given (word,byte) combo.  This is a
+        ///   computation defined by PKzip for PKZIP 2.0 (weak) encryption.
+        /// </summary>
+        /// <param name="W">The word to start with.</param>
+        /// <param name="B">The byte to combine it with.</param>
+        /// <returns>The CRC-ized result.</returns>
+        internal Int32 ComputeCrc32(Int32 W, byte B)
+        {
+            return _InternalComputeCrc32((UInt32)W, B);
+        }
+
+        internal Int32 _InternalComputeCrc32(UInt32 W, byte B)
+        {
+            return (Int32)(crc32Table[(W ^ B) & 0xFF] ^ (W >> 8));
+        }
+
+
+        /// <summary>
+        /// Update the value for the running CRC32 using the given block of bytes.
+        /// This is useful when using the CRC32() class in a Stream.
+        /// </summary>
+        /// <param name="block">block of bytes to slurp</param>
+        /// <param name="offset">starting point in the block</param>
+        /// <param name="count">how many bytes within the block to slurp</param>
+        internal void SlurpBlock(byte[] block, int offset, int count)
+        {
+            if (block == null)
+                throw new Exception("The data buffer must not be null.");
+
+            // bzip algorithm
+            for (int i = 0; i < count; i++)
+            {
+                int x = offset + i;
+                byte b = block[x];
+                if (this.reverseBits)
+                {
+                    UInt32 temp = (_register >> 24) ^ b;
+                    _register = (_register << 8) ^ crc32Table[temp];
+                }
+                else
+                {
+                    UInt32 temp = (_register & 0x000000FF) ^ b;
+                    _register = (_register >> 8) ^ crc32Table[temp];
+                }
+            }
+            _TotalBytesRead += count;
+        }
+
+
+        /// <summary>
+        ///   Process one byte in the CRC.
+        /// </summary>
+        /// <param name = "b">the byte to include into the CRC .  </param>
+        internal void UpdateCRC(byte b)
+        {
+            if (this.reverseBits)
+            {
+                UInt32 temp = (_register >> 24) ^ b;
+                _register = (_register << 8) ^ crc32Table[temp];
+            }
+            else
+            {
+                UInt32 temp = (_register & 0x000000FF) ^ b;
+                _register = (_register >> 8) ^ crc32Table[temp];
+            }
+        }
+
+        /// <summary>
+        ///   Process a run of N identical bytes into the CRC.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     This method serves as an optimization for updating the CRC when a
+        ///     run of identical bytes is found. Rather than passing in a buffer of
+        ///     length n, containing all identical bytes b, this method accepts the
+        ///     byte value and the length of the (virtual) buffer - the length of
+        ///     the run.
+        ///   </para>
+        /// </remarks>
+        /// <param name = "b">the byte to include into the CRC.  </param>
+        /// <param name = "n">the number of times that byte should be repeated. </param>
+        internal void UpdateCRC(byte b, int n)
+        {
+            while (n-- > 0)
+            {
+                if (this.reverseBits)
+                {
+                    uint temp = (_register >> 24) ^ b;
+                    _register = (_register << 8) ^ crc32Table[(temp >= 0)
+                                                              ? temp
+                                                              : (temp + 256)];
+                }
+                else
+                {
+                    UInt32 temp = (_register & 0x000000FF) ^ b;
+                    _register = (_register >> 8) ^ crc32Table[(temp >= 0)
+                                                              ? temp
+                                                              : (temp + 256)];
+
+                }
+            }
+        }
+
+
+
+        private static uint ReverseBits(uint data)
+        {
+            unchecked
+            {
+                uint ret = data;
+                ret = (ret & 0x55555555) << 1 | (ret >> 1) & 0x55555555;
+                ret = (ret & 0x33333333) << 2 | (ret >> 2) & 0x33333333;
+                ret = (ret & 0x0F0F0F0F) << 4 | (ret >> 4) & 0x0F0F0F0F;
+                ret = (ret << 24) | ((ret & 0xFF00) << 8) | ((ret >> 8) & 0xFF00) | (ret >> 24);
+                return ret;
+            }
+        }
+
+        private static byte ReverseBits(byte data)
+        {
+            unchecked
+            {
+                uint u = (uint)data * 0x00020202;
+                uint m = 0x01044010;
+                uint s = u & m;
+                uint t = (u << 2) & (m << 1);
+                return (byte)((0x01001001 * (s + t)) >> 24);
+            }
+        }
+
+
+
+        private void GenerateLookupTable()
+        {
+            crc32Table = new UInt32[256];
+            unchecked
+            {
+                UInt32 dwCrc;
+                byte i = 0;
+                do
+                {
+                    dwCrc = i;
+                    for (byte j = 8; j > 0; j--)
+                    {
+                        if ((dwCrc & 1) == 1)
+                        {
+                            dwCrc = (dwCrc >> 1) ^ dwPolynomial;
+                        }
+                        else
+                        {
+                            dwCrc >>= 1;
+                        }
+                    }
+                    if (reverseBits)
+                    {
+                        crc32Table[ReverseBits(i)] = ReverseBits(dwCrc);
+                    }
+                    else
+                    {
+                        crc32Table[i] = dwCrc;
+                    }
+                    i++;
+                } while (i != 0);
+            }
+
+#if VERBOSE
+            Console.WriteLine();
+            Console.WriteLine("private static readonly UInt32[] crc32Table = {");
+            for (int i = 0; i < crc32Table.Length; i+=4)
+            {
+                Console.Write("   ");
+                for (int j=0; j < 4; j++)
+                {
+                    Console.Write(" 0x{0:X8}U,", crc32Table[i+j]);
+                }
+                Console.WriteLine();
+            }
+            Console.WriteLine("};");
+            Console.WriteLine();
+#endif
+        }
+
+
+        private uint gf2_matrix_times(uint[] matrix, uint vec)
+        {
+            uint sum = 0;
+            int i = 0;
+            while (vec != 0)
+            {
+                if ((vec & 0x01) == 0x01)
+                    sum ^= matrix[i];
+                vec >>= 1;
+                i++;
+            }
+            return sum;
+        }
+
+        private void gf2_matrix_square(uint[] square, uint[] mat)
+        {
+            for (int i = 0; i < 32; i++)
+                square[i] = gf2_matrix_times(mat, mat[i]);
+        }
+
+
+
+        /// <summary>
+        ///   Combines the given CRC32 value with the current running total.
+        /// </summary>
+        /// <remarks>
+        ///   This is useful when using a divide-and-conquer approach to
+        ///   calculating a CRC.  Multiple threads can each calculate a
+        ///   CRC32 on a segment of the data, and then combine the
+        ///   individual CRC32 values at the end.
+        /// </remarks>
+        /// <param name="crc">the crc value to be combined with this one</param>
+        /// <param name="length">the length of data the CRC value was calculated on</param>
+        internal void Combine(int crc, int length)
+        {
+            uint[] even = new uint[32];     // even-power-of-two zeros operator
+            uint[] odd = new uint[32];      // odd-power-of-two zeros operator
+
+            if (length == 0)
+                return;
+
+            uint crc1 = ~_register;
+            uint crc2 = (uint)crc;
+
+            // put operator for one zero bit in odd
+            odd[0] = this.dwPolynomial;  // the CRC-32 polynomial
+            uint row = 1;
+            for (int i = 1; i < 32; i++)
+            {
+                odd[i] = row;
+                row <<= 1;
+            }
+
+            // put operator for two zero bits in even
+            gf2_matrix_square(even, odd);
+
+            // put operator for four zero bits in odd
+            gf2_matrix_square(odd, even);
+
+            uint len2 = (uint)length;
+
+            // apply len2 zeros to crc1 (first square will put the operator for one
+            // zero byte, eight zero bits, in even)
+            do
+            {
+                // apply zeros operator for this bit of len2
+                gf2_matrix_square(even, odd);
+
+                if ((len2 & 1) == 1)
+                    crc1 = gf2_matrix_times(even, crc1);
+                len2 >>= 1;
+
+                if (len2 == 0)
+                    break;
+
+                // another iteration of the loop with odd and even swapped
+                gf2_matrix_square(odd, even);
+                if ((len2 & 1) == 1)
+                    crc1 = gf2_matrix_times(odd, crc1);
+                len2 >>= 1;
+
+
+            } while (len2 != 0);
+
+            crc1 ^= crc2;
+
+            _register = ~crc1;
+
+            //return (int) crc1;
+            return;
+        }
+
+
+        /// <summary>
+        ///   Create an instance of the CRC32 class using the default settings: no
+        ///   bit reversal, and a polynomial of 0xEDB88320.
+        /// </summary>
+        internal CRC32()
+            : this(false)
+        {
+        }
+
+        /// <summary>
+        ///   Create an instance of the CRC32 class, specifying whether to reverse
+        ///   data bits or not.
+        /// </summary>
+        /// <param name='reverseBits'>
+        ///   specify true if the instance should reverse data bits.
+        /// </param>
+        /// <remarks>
+        ///   <para>
+        ///     In the CRC-32 used by BZip2, the bits are reversed. Therefore if you
+        ///     want a CRC32 with compatibility with BZip2, you should pass true
+        ///     here. In the CRC-32 used by GZIP and PKZIP, the bits are not
+        ///     reversed; Therefore if you want a CRC32 with compatibility with
+        ///     those, you should pass false.
+        ///   </para>
+        /// </remarks>
+        internal CRC32(bool reverseBits) :
+            this(unchecked((int)0xEDB88320), reverseBits)
+        {
+        }
+
+
+        /// <summary>
+        ///   Create an instance of the CRC32 class, specifying the polynomial and
+        ///   whether to reverse data bits or not.
+        /// </summary>
+        /// <param name='polynomial'>
+        ///   The polynomial to use for the CRC, expressed in the reversed (LSB)
+        ///   format: the highest ordered bit in the polynomial value is the
+        ///   coefficient of the 0th power; the second-highest order bit is the
+        ///   coefficient of the 1 power, and so on. Expressed this way, the
+        ///   polynomial for the CRC-32C used in IEEE 802.3, is 0xEDB88320.
+        /// </param>
+        /// <param name='reverseBits'>
+        ///   specify true if the instance should reverse data bits.
+        /// </param>
+        ///
+        /// <remarks>
+        ///   <para>
+        ///     In the CRC-32 used by BZip2, the bits are reversed. Therefore if you
+        ///     want a CRC32 with compatibility with BZip2, you should pass true
+        ///     here for the <c>reverseBits</c> parameter. In the CRC-32 used by
+        ///     GZIP and PKZIP, the bits are not reversed; Therefore if you want a
+        ///     CRC32 with compatibility with those, you should pass false for the
+        ///     <c>reverseBits</c> parameter.
+        ///   </para>
+        /// </remarks>
+        internal CRC32(int polynomial, bool reverseBits)
+        {
+            this.reverseBits = reverseBits;
+            this.dwPolynomial = (uint)polynomial;
+            this.GenerateLookupTable();
+        }
+
+        /// <summary>
+        ///   Reset the CRC-32 class - clear the CRC "remainder register."
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     Use this when employing a single instance of this class to compute
+        ///     multiple, distinct CRCs on multiple, distinct data blocks.
+        ///   </para>
+        /// </remarks>
+        internal void Reset()
+        {
+            _register = 0xFFFFFFFFU;
+        }
+
+        // private member vars
+        private UInt32 dwPolynomial;
+        private Int64 _TotalBytesRead;
+        private bool reverseBits;
+        private UInt32[] crc32Table;
+        private const int BUFFER_SIZE = 8192;
+        private UInt32 _register = 0xFFFFFFFFU;
+    }
+
+
+    /// <summary>
+    /// A Stream that calculates a CRC32 (a checksum) on all bytes read,
+    /// or on all bytes written.
+    /// </summary>
+    ///
+    /// <remarks>
+    /// <para>
+    /// This class can be used to verify the CRC of a ZipEntry when
+    /// reading from a stream, or to calculate a CRC when writing to a
+    /// stream.  The stream should be used to either read, or write, but
+    /// not both.  If you intermix reads and writes, the results are not
+    /// defined.
+    /// </para>
+    ///
+    /// <para>
+    /// This class is intended primarily for use internally by the
+    /// DotNetZip library.
+    /// </para>
+    /// </remarks>
+    internal class CrcCalculatorStream : System.IO.Stream, System.IDisposable
+    {
+        private static readonly Int64 UnsetLengthLimit = -99;
+
+        internal System.IO.Stream _innerStream;
+        private CRC32 _Crc32;
+        private Int64 _lengthLimit = -99;
+        private bool _leaveOpen;
+
+        /// <summary>
+        /// The default constructor.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     Instances returned from this constructor will leave the underlying
+        ///     stream open upon Close().  The stream uses the default CRC32
+        ///     algorithm, which implies a polynomial of 0xEDB88320.
+        ///   </para>
+        /// </remarks>
+        /// <param name="stream">The underlying stream</param>
+        internal CrcCalculatorStream(System.IO.Stream stream)
+            : this(true, CrcCalculatorStream.UnsetLengthLimit, stream, null)
+        {
+        }
+
+        /// <summary>
+        ///   The constructor allows the caller to specify how to handle the
+        ///   underlying stream at close.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     The stream uses the default CRC32 algorithm, which implies a
+        ///     polynomial of 0xEDB88320.
+        ///   </para>
+        /// </remarks>
+        /// <param name="stream">The underlying stream</param>
+        /// <param name="leaveOpen">true to leave the underlying stream
+        /// open upon close of the <c>CrcCalculatorStream</c>; false otherwise.</param>
+        internal CrcCalculatorStream(System.IO.Stream stream, bool leaveOpen)
+            : this(leaveOpen, CrcCalculatorStream.UnsetLengthLimit, stream, null)
+        {
+        }
+
+        /// <summary>
+        ///   A constructor allowing the specification of the length of the stream
+        ///   to read.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     The stream uses the default CRC32 algorithm, which implies a
+        ///     polynomial of 0xEDB88320.
+        ///   </para>
+        ///   <para>
+        ///     Instances returned from this constructor will leave the underlying
+        ///     stream open upon Close().
+        ///   </para>
+        /// </remarks>
+        /// <param name="stream">The underlying stream</param>
+        /// <param name="length">The length of the stream to slurp</param>
+        internal CrcCalculatorStream(System.IO.Stream stream, Int64 length)
+            : this(true, length, stream, null)
+        {
+            if (length < 0)
+                throw new ArgumentException("length");
+        }
+
+        /// <summary>
+        ///   A constructor allowing the specification of the length of the stream
+        ///   to read, as well as whether to keep the underlying stream open upon
+        ///   Close().
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     The stream uses the default CRC32 algorithm, which implies a
+        ///     polynomial of 0xEDB88320.
+        ///   </para>
+        /// </remarks>
+        /// <param name="stream">The underlying stream</param>
+        /// <param name="length">The length of the stream to slurp</param>
+        /// <param name="leaveOpen">true to leave the underlying stream
+        /// open upon close of the <c>CrcCalculatorStream</c>; false otherwise.</param>
+        internal CrcCalculatorStream(System.IO.Stream stream, Int64 length, bool leaveOpen)
+            : this(leaveOpen, length, stream, null)
+        {
+            if (length < 0)
+                throw new ArgumentException("length");
+        }
+
+        /// <summary>
+        ///   A constructor allowing the specification of the length of the stream
+        ///   to read, as well as whether to keep the underlying stream open upon
+        ///   Close(), and the CRC32 instance to use.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     The stream uses the specified CRC32 instance, which allows the
+        ///     application to specify how the CRC gets calculated.
+        ///   </para>
+        /// </remarks>
+        /// <param name="stream">The underlying stream</param>
+        /// <param name="length">The length of the stream to slurp</param>
+        /// <param name="leaveOpen">true to leave the underlying stream
+        /// open upon close of the <c>CrcCalculatorStream</c>; false otherwise.</param>
+        /// <param name="crc32">the CRC32 instance to use to calculate the CRC32</param>
+        internal CrcCalculatorStream(System.IO.Stream stream, Int64 length, bool leaveOpen,
+                                   CRC32 crc32)
+            : this(leaveOpen, length, stream, crc32)
+        {
+            if (length < 0)
+                throw new ArgumentException("length");
+        }
+
+
+        // This ctor is private - no validation is done here.  This is to allow the use
+        // of a (specific) negative value for the _lengthLimit, to indicate that there
+        // is no length set.  So we validate the length limit in those ctors that use an
+        // explicit param, otherwise we don't validate, because it could be our special
+        // value.
+        private CrcCalculatorStream
+            (bool leaveOpen, Int64 length, System.IO.Stream stream, CRC32 crc32)
+            : base()
+        {
+            _innerStream = stream;
+            _Crc32 = crc32 ?? new CRC32();
+            _lengthLimit = length;
+            _leaveOpen = leaveOpen;
+        }
+
+
+        /// <summary>
+        ///   Gets the total number of bytes run through the CRC32 calculator.
+        /// </summary>
+        ///
+        /// <remarks>
+        ///   This is either the total number of bytes read, or the total number of
+        ///   bytes written, depending on the direction of this stream.
+        /// </remarks>
+        internal Int64 TotalBytesSlurped
+        {
+            get { return _Crc32.TotalBytesRead; }
+        }
+
+        /// <summary>
+        ///   Provides the current CRC for all blocks slurped in.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     The running total of the CRC is kept as data is written or read
+        ///     through the stream.  read this property after all reads or writes to
+        ///     get an accurate CRC for the entire stream.
+        ///   </para>
+        /// </remarks>
+        internal Int32 Crc
+        {
+            get { return _Crc32.Crc32Result; }
+        }
+
+        /// <summary>
+        ///   Indicates whether the underlying stream will be left open when the
+        ///   <c>CrcCalculatorStream</c> is Closed.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     Set this at any point before calling <see cref="Stream.Close"/>.
+        ///   </para>
+        /// </remarks>
+        internal bool LeaveOpen
+        {
+            get { return _leaveOpen; }
+            set { _leaveOpen = value; }
+        }
+
+        /// <summary>
+        /// Read from the stream
+        /// </summary>
+        /// <param name="buffer">the buffer to read</param>
+        /// <param name="offset">the offset at which to start</param>
+        /// <param name="count">the number of bytes to read</param>
+        /// <returns>the number of bytes actually read</returns>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            int bytesToRead = count;
+
+            // Need to limit the # of bytes returned, if the stream is intended to have
+            // a definite length.  This is especially useful when returning a stream for
+            // the uncompressed data directly to the application.  The app won't
+            // necessarily read only the UncompressedSize number of bytes.  For example
+            // wrapping the stream returned from OpenReader() into a StreadReader() and
+            // calling ReadToEnd() on it, We can "over-read" the zip data and get a
+            // corrupt string.  The length limits that, prevents that problem.
+
+            if (_lengthLimit != CrcCalculatorStream.UnsetLengthLimit)
+            {
+                if (_Crc32.TotalBytesRead >= _lengthLimit) return 0; // EOF
+                Int64 bytesRemaining = _lengthLimit - _Crc32.TotalBytesRead;
+                if (bytesRemaining < count) bytesToRead = (int)bytesRemaining;
+            }
+            int n = _innerStream.Read(buffer, offset, bytesToRead);
+            if (n > 0) _Crc32.SlurpBlock(buffer, offset, n);
+            return n;
+        }
+
+        /// <summary>
+        /// Write to the stream.
+        /// </summary>
+        /// <param name="buffer">the buffer from which to write</param>
+        /// <param name="offset">the offset at which to start writing</param>
+        /// <param name="count">the number of bytes to write</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (count > 0) _Crc32.SlurpBlock(buffer, offset, count);
+            _innerStream.Write(buffer, offset, count);
+        }
+
+        /// <summary>
+        /// Indicates whether the stream supports reading.
+        /// </summary>
+        public override bool CanRead
+        {
+            get { return _innerStream.CanRead; }
+        }
+
+        /// <summary>
+        ///   Indicates whether the stream supports seeking.
+        /// </summary>
+        /// <remarks>
+        ///   <para>
+        ///     Always returns false.
+        ///   </para>
+        /// </remarks>
+        public override bool CanSeek
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// Indicates whether the stream supports writing.
+        /// </summary>
+        public override bool CanWrite
+        {
+            get { return _innerStream.CanWrite; }
+        }
+
+        /// <summary>
+        /// Flush the stream.
+        /// </summary>
+        public override void Flush()
+        {
+            _innerStream.Flush();
+        }
+
+        /// <summary>
+        ///   Returns the length of the underlying stream.
+        /// </summary>
+        public override long Length
+        {
+            get
+            {
+                if (_lengthLimit == CrcCalculatorStream.UnsetLengthLimit)
+                    return _innerStream.Length;
+                else return _lengthLimit;
+            }
+        }
+
+        /// <summary>
+        ///   The getter for this property returns the total bytes read.
+        ///   If you use the setter, it will throw
+        /// <see cref="NotSupportedException"/>.
+        /// </summary>
+        public override long Position
+        {
+            get { return _Crc32.TotalBytesRead; }
+            set { throw new NotSupportedException(); }
+        }
+
+        /// <summary>
+        /// Seeking is not supported on this stream. This method always throws
+        /// <see cref="NotSupportedException"/>
+        /// </summary>
+        /// <param name="offset">N/A</param>
+        /// <param name="origin">N/A</param>
+        /// <returns>N/A</returns>
+        public override long Seek(long offset, System.IO.SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// This method always throws
+        /// <see cref="NotSupportedException"/>
+        /// </summary>
+        /// <param name="value">N/A</param>
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+
+        void IDisposable.Dispose()
+        {
+            base.Dispose();
+        }
+    }
+
+    /// <summary>
+    /// A custom encoding class that provides encoding capabilities for the
+    /// 'Western European (ISO)' encoding under Silverlight.<br/>
+    /// This class was generated by a tool. For more information, visit
+    /// http://www.hardcodet.net/2010/03/silverlight-text-encoding-class-generator
+    /// </summary>
+    internal class Iso88591Encoding : Encoding
+    {
+        /// <summary>
+        /// Gets the name registered with the
+        /// Internet Assigned Numbers Authority (IANA) for the current encoding.
+        /// </summary>
+        /// <returns>
+        /// The IANA name for the current <see cref="System.Text.Encoding"/>.
+        /// </returns>
+        public override string WebName
+        {
+            get
+            {
+                return "iso-8859-1";
+            }
+        }
+
+
+        private char? fallbackCharacter;
+
+        /// <summary>
+        /// A character that can be set in order to make the encoding class
+        /// more fault tolerant. If this property is set, the encoding class will
+        /// use this property instead of throwing an exception if an unsupported
+        /// byte value is being passed for decoding.
+        /// </summary>
+        public char? FallbackCharacter
+        {
+            get { return fallbackCharacter; }
+            set
+            {
+                fallbackCharacter = value;
+
+                if (value.HasValue && !charToByte.ContainsKey(value.Value))
+                {
+                    string msg = "Cannot use the character [{0}] (int value {1}) as fallback value "
+                    + "- the fallback character itself is not supported by the encoding.";
+                    msg = String.Format(msg, value.Value, (int)value.Value);
+                    throw new EncoderFallbackException(msg);
+                }
+
+                FallbackByte = value.HasValue ? charToByte[value.Value] : (byte?)null;
+            }
+        }
+
+        /// <summary>
+        /// A byte value that corresponds to the <see cref="FallbackCharacter"/>.
+        /// It is used in encoding scenarios in case an unsupported character is
+        /// being passed for encoding.
+        /// </summary>
+        public byte? FallbackByte { get; private set; }
+
+
+        public Iso88591Encoding()
+        {
+            FallbackCharacter = '?';
+        }
+
+        /// <summary>
+        /// Encodes a set of characters from the specified character array into the specified byte array.
+        /// </summary>
+        /// <returns>
+        /// The actual number of bytes written into <paramref name="bytes"/>.
+        /// </returns>
+        /// <param name="chars">The character array containing the set of characters to encode. 
+        /// </param><param name="charIndex">The index of the first character to encode. 
+        /// </param><param name="charCount">The number of characters to encode. 
+        /// </param><param name="bytes">The byte array to contain the resulting sequence of bytes.
+        /// </param><param name="byteIndex">The index at which to start writing the resulting sequence of bytes. 
+        /// </param>
+        public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
+        {
+            return FallbackByte.HasValue
+                     ? GetBytesWithFallBack(chars, charIndex, charCount, bytes, byteIndex)
+                     : GetBytesWithoutFallback(chars, charIndex, charCount, bytes, byteIndex);
+        }
+
+
+        private int GetBytesWithFallBack(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
+        {
+            for (int i = 0; i < charCount; i++)
+            {
+                var character = chars[i + charIndex];
+                byte byteValue;
+                bool status = charToByte.TryGetValue(character, out byteValue);
+
+                bytes[byteIndex + i] = status ? byteValue : FallbackByte.Value;
+            }
+
+            return charCount;
+        }
+
+        private int GetBytesWithoutFallback(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
+        {
+            for (int i = 0; i < charCount; i++)
+            {
+                var character = chars[i + charIndex];
+                byte byteValue;
+                bool status = charToByte.TryGetValue(character, out byteValue);
+
+                if (!status)
+                {
+                    //throw exception
+                    string msg =
+                      "The encoding [{0}] cannot encode the character [{1}] (int value {2}). Set the FallbackCharacter property in order to suppress this exception and encode a default character instead.";
+                    msg = String.Format(msg, WebName, character, (int)character);
+                    throw new EncoderFallbackException(msg);
+                }
+
+                bytes[byteIndex + i] = byteValue;
+            }
+
+            return charCount;
+        }
+
+
+
+        /// <summary>
+        /// Decodes a sequence of bytes from the specified byte array into the specified character array.
+        /// </summary>
+        /// <returns>
+        /// The actual number of characters written into <paramref name="chars"/>.
+        /// </returns>
+        /// <param name="bytes">The byte array containing the sequence of bytes to decode. 
+        /// </param><param name="byteIndex">The index of the first byte to decode. 
+        /// </param><param name="byteCount">The number of bytes to decode. 
+        /// </param><param name="chars">The character array to contain the resulting set of characters. 
+        /// </param><param name="charIndex">The index at which to start writing the resulting set of characters. 
+        /// </param>
+        public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
+        {
+            return FallbackCharacter.HasValue
+                     ? GetCharsWithFallback(bytes, byteIndex, byteCount, chars, charIndex)
+                     : GetCharsWithoutFallback(bytes, byteIndex, byteCount, chars, charIndex);
+        }
+
+
+        private int GetCharsWithFallback(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
+        {
+            for (int i = 0; i < byteCount; i++)
+            {
+                byte lookupIndex = bytes[i + byteIndex];
+
+                //if the byte value is not in our lookup array, fall back to default character
+                char result = lookupIndex >= byteToChar.Length
+                                ? FallbackCharacter.Value
+                                : byteToChar[lookupIndex];
+
+                chars[charIndex + i] = result;
+            }
+
+            return byteCount;
+        }
+
+
+
+        private int GetCharsWithoutFallback(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
+        {
+            for (int i = 0; i < byteCount; i++)
+            {
+                byte lookupIndex = bytes[i + byteIndex];
+                if (lookupIndex >= byteToChar.Length)
+                {
+                    //throw exception
+                    string msg = "The encoding [{0}] cannot decode byte value [{1}]. Set the FallbackCharacter property in order to suppress this exception and decode the value as a default character instead.";
+                    msg = String.Format(msg, WebName, lookupIndex);
+                    throw new EncoderFallbackException(msg);
+                }
+
+
+                chars[charIndex + i] = byteToChar[lookupIndex];
+            }
+
+            return byteCount;
+        }
+
+
+
+        /// <summary>
+        /// Calculates the number of bytes produced by encoding a set of characters
+        /// from the specified character array.
+        /// </summary>
+        /// <returns>
+        /// The number of bytes produced by encoding the specified characters. This class
+        /// always returns the value of <paramref name="count"/>.
+        /// </returns>
+        public override int GetByteCount(char[] chars, int index, int count)
+        {
+            return count;
+        }
+
+
+        /// <summary>
+        /// Calculates the number of characters produced by decoding a sequence
+        /// of bytes from the specified byte array.
+        /// </summary>
+        /// <returns>
+        /// The number of characters produced by decoding the specified sequence of bytes. This class
+        /// always returns the value of <paramref name="count"/>. 
+        /// </returns>
+        public override int GetCharCount(byte[] bytes, int index, int count)
+        {
+            return count;
+        }
+
+
+        /// <summary>
+        /// Calculates the maximum number of bytes produced by encoding the specified number of characters.
+        /// </summary>
+        /// <returns>
+        /// The maximum number of bytes produced by encoding the specified number of characters. This
+        /// class always returns the value of <paramref name="charCount"/>.
+        /// </returns>
+        /// <param name="charCount">The number of characters to encode. 
+        /// </param>
+        public override int GetMaxByteCount(int charCount)
+        {
+            return charCount;
+        }
+
+        /// <summary>
+        /// Calculates the maximum number of characters produced by decoding the specified number of bytes.
+        /// </summary>
+        /// <returns>
+        /// The maximum number of characters produced by decoding the specified number of bytes. This class
+        /// always returns the value of <paramref name="byteCount"/>.
+        /// </returns>
+        /// <param name="byteCount">The number of bytes to decode.</param> 
+        public override int GetMaxCharCount(int byteCount)
+        {
+            return byteCount;
+        }
+
+
+        /// <summary>
+        /// Gets the number of characters that are supported by this encoding.
+        /// This property returns a maximum value of 256, as the encoding class
+        /// only supports single byte encodings (1 byte == 256 possible values).
+        /// </summary>
+        public static int CharacterCount
+        {
+            get { return byteToChar.Length; }
+        }
+
+        #region Character Table
+
+        /// <summary>
+        /// This table contains characters in an array. The index within the
+        /// array corresponds to the encoding's mapping of bytes to characters
+        /// (e.g. if a byte value of 5 is used to encode the character 'x', this
+        /// character will be stored at the array index 5.
+        /// </summary>
+        private static char[] byteToChar = new char[]
+        {
+          (char)0 /* byte 0 */  ,
+          (char)1 /* byte 1 */  ,
+          (char)2 /* byte 2 */  ,
+          (char)3 /* byte 3 */  ,
+          (char)4 /* byte 4 */  ,
+          (char)5 /* byte 5 */  ,
+          (char)6 /* byte 6 */  ,
+          (char)7 /* byte 7 */  ,
+          (char)8 /* byte 8 */  ,
+          (char)9 /* byte 9 */  ,
+          (char)10 /* byte 10 */  ,
+          (char)11 /* byte 11 */  ,
+          (char)12 /* byte 12 */  ,
+          (char)13 /* byte 13 */  ,
+          (char)14 /* byte 14 */  ,
+          (char)15 /* byte 15 */  ,
+          (char)16 /* byte 16 */  ,
+          (char)17 /* byte 17 */  ,
+          (char)18 /* byte 18 */  ,
+          (char)19 /* byte 19 */  ,
+          (char)20 /* byte 20 */  ,
+          (char)21 /* byte 21 */  ,
+          (char)22 /* byte 22 */  ,
+          (char)23 /* byte 23 */  ,
+          (char)24 /* byte 24 */  ,
+          (char)25 /* byte 25 */  ,
+          (char)26 /* byte 26 */  ,
+          (char)27 /* byte 27 */  ,
+          (char)28 /* byte 28 */  ,
+          (char)29 /* byte 29 */  ,
+          (char)30 /* byte 30 */  ,
+          (char)31 /* byte 31 */  ,
+          (char)32 /* byte 32 */  ,
+          (char)33 /* byte 33 */  ,
+          (char)34 /* byte 34 */  ,
+          (char)35 /* byte 35 */  ,
+          (char)36 /* byte 36 */  ,
+          (char)37 /* byte 37 */  ,
+          (char)38 /* byte 38 */  ,
+          (char)39 /* byte 39 */  ,
+          (char)40 /* byte 40 */  ,
+          (char)41 /* byte 41 */  ,
+          (char)42 /* byte 42 */  ,
+          (char)43 /* byte 43 */  ,
+          (char)44 /* byte 44 */  ,
+          (char)45 /* byte 45 */  ,
+          (char)46 /* byte 46 */  ,
+          (char)47 /* byte 47 */  ,
+          (char)48 /* byte 48 */  ,
+          (char)49 /* byte 49 */  ,
+          (char)50 /* byte 50 */  ,
+          (char)51 /* byte 51 */  ,
+          (char)52 /* byte 52 */  ,
+          (char)53 /* byte 53 */  ,
+          (char)54 /* byte 54 */  ,
+          (char)55 /* byte 55 */  ,
+          (char)56 /* byte 56 */  ,
+          (char)57 /* byte 57 */  ,
+          (char)58 /* byte 58 */  ,
+          (char)59 /* byte 59 */  ,
+          (char)60 /* byte 60 */  ,
+          (char)61 /* byte 61 */  ,
+          (char)62 /* byte 62 */  ,
+          (char)63 /* byte 63 */  ,
+          (char)64 /* byte 64 */  ,
+          (char)65 /* byte 65 */  ,
+          (char)66 /* byte 66 */  ,
+          (char)67 /* byte 67 */  ,
+          (char)68 /* byte 68 */  ,
+          (char)69 /* byte 69 */  ,
+          (char)70 /* byte 70 */  ,
+          (char)71 /* byte 71 */  ,
+          (char)72 /* byte 72 */  ,
+          (char)73 /* byte 73 */  ,
+          (char)74 /* byte 74 */  ,
+          (char)75 /* byte 75 */  ,
+          (char)76 /* byte 76 */  ,
+          (char)77 /* byte 77 */  ,
+          (char)78 /* byte 78 */  ,
+          (char)79 /* byte 79 */  ,
+          (char)80 /* byte 80 */  ,
+          (char)81 /* byte 81 */  ,
+          (char)82 /* byte 82 */  ,
+          (char)83 /* byte 83 */  ,
+          (char)84 /* byte 84 */  ,
+          (char)85 /* byte 85 */  ,
+          (char)86 /* byte 86 */  ,
+          (char)87 /* byte 87 */  ,
+          (char)88 /* byte 88 */  ,
+          (char)89 /* byte 89 */  ,
+          (char)90 /* byte 90 */  ,
+          (char)91 /* byte 91 */  ,
+          (char)92 /* byte 92 */  ,
+          (char)93 /* byte 93 */  ,
+          (char)94 /* byte 94 */  ,
+          (char)95 /* byte 95 */  ,
+          (char)96 /* byte 96 */  ,
+          (char)97 /* byte 97 */  ,
+          (char)98 /* byte 98 */  ,
+          (char)99 /* byte 99 */  ,
+          (char)100 /* byte 100 */  ,
+          (char)101 /* byte 101 */  ,
+          (char)102 /* byte 102 */  ,
+          (char)103 /* byte 103 */  ,
+          (char)104 /* byte 104 */  ,
+          (char)105 /* byte 105 */  ,
+          (char)106 /* byte 106 */  ,
+          (char)107 /* byte 107 */  ,
+          (char)108 /* byte 108 */  ,
+          (char)109 /* byte 109 */  ,
+          (char)110 /* byte 110 */  ,
+          (char)111 /* byte 111 */  ,
+          (char)112 /* byte 112 */  ,
+          (char)113 /* byte 113 */  ,
+          (char)114 /* byte 114 */  ,
+          (char)115 /* byte 115 */  ,
+          (char)116 /* byte 116 */  ,
+          (char)117 /* byte 117 */  ,
+          (char)118 /* byte 118 */  ,
+          (char)119 /* byte 119 */  ,
+          (char)120 /* byte 120 */  ,
+          (char)121 /* byte 121 */  ,
+          (char)122 /* byte 122 */  ,
+          (char)123 /* byte 123 */  ,
+          (char)124 /* byte 124 */  ,
+          (char)125 /* byte 125 */  ,
+          (char)126 /* byte 126 */  ,
+          (char)127 /* byte 127 */  ,
+          (char)128 /* byte 128 */  ,
+          (char)129 /* byte 129 */  ,
+          (char)130 /* byte 130 */  ,
+          (char)131 /* byte 131 */  ,
+          (char)132 /* byte 132 */  ,
+          (char)133 /* byte 133 */  ,
+          (char)134 /* byte 134 */  ,
+          (char)135 /* byte 135 */  ,
+          (char)136 /* byte 136 */  ,
+          (char)137 /* byte 137 */  ,
+          (char)138 /* byte 138 */  ,
+          (char)139 /* byte 139 */  ,
+          (char)140 /* byte 140 */  ,
+          (char)141 /* byte 141 */  ,
+          (char)142 /* byte 142 */  ,
+          (char)143 /* byte 143 */  ,
+          (char)144 /* byte 144 */  ,
+          (char)145 /* byte 145 */  ,
+          (char)146 /* byte 146 */  ,
+          (char)147 /* byte 147 */  ,
+          (char)148 /* byte 148 */  ,
+          (char)149 /* byte 149 */  ,
+          (char)150 /* byte 150 */  ,
+          (char)151 /* byte 151 */  ,
+          (char)152 /* byte 152 */  ,
+          (char)153 /* byte 153 */  ,
+          (char)154 /* byte 154 */  ,
+          (char)155 /* byte 155 */  ,
+          (char)156 /* byte 156 */  ,
+          (char)157 /* byte 157 */  ,
+          (char)158 /* byte 158 */  ,
+          (char)159 /* byte 159 */  ,
+          (char)160 /* byte 160 */  ,
+          (char)161 /* byte 161 */  ,
+          (char)162 /* byte 162 */  ,
+          (char)163 /* byte 163 */  ,
+          (char)164 /* byte 164 */  ,
+          (char)165 /* byte 165 */  ,
+          (char)166 /* byte 166 */  ,
+          (char)167 /* byte 167 */  ,
+          (char)168 /* byte 168 */  ,
+          (char)169 /* byte 169 */  ,
+          (char)170 /* byte 170 */  ,
+          (char)171 /* byte 171 */  ,
+          (char)172 /* byte 172 */  ,
+          (char)173 /* byte 173 */  ,
+          (char)174 /* byte 174 */  ,
+          (char)175 /* byte 175 */  ,
+          (char)176 /* byte 176 */  ,
+          (char)177 /* byte 177 */  ,
+          (char)178 /* byte 178 */  ,
+          (char)179 /* byte 179 */  ,
+          (char)180 /* byte 180 */  ,
+          (char)181 /* byte 181 */  ,
+          (char)182 /* byte 182 */  ,
+          (char)183 /* byte 183 */  ,
+          (char)184 /* byte 184 */  ,
+          (char)185 /* byte 185 */  ,
+          (char)186 /* byte 186 */  ,
+          (char)187 /* byte 187 */  ,
+          (char)188 /* byte 188 */  ,
+          (char)189 /* byte 189 */  ,
+          (char)190 /* byte 190 */  ,
+          (char)191 /* byte 191 */  ,
+          (char)192 /* byte 192 */  ,
+          (char)193 /* byte 193 */  ,
+          (char)194 /* byte 194 */  ,
+          (char)195 /* byte 195 */  ,
+          (char)196 /* byte 196 */  ,
+          (char)197 /* byte 197 */  ,
+          (char)198 /* byte 198 */  ,
+          (char)199 /* byte 199 */  ,
+          (char)200 /* byte 200 */  ,
+          (char)201 /* byte 201 */  ,
+          (char)202 /* byte 202 */  ,
+          (char)203 /* byte 203 */  ,
+          (char)204 /* byte 204 */  ,
+          (char)205 /* byte 205 */  ,
+          (char)206 /* byte 206 */  ,
+          (char)207 /* byte 207 */  ,
+          (char)208 /* byte 208 */  ,
+          (char)209 /* byte 209 */  ,
+          (char)210 /* byte 210 */  ,
+          (char)211 /* byte 211 */  ,
+          (char)212 /* byte 212 */  ,
+          (char)213 /* byte 213 */  ,
+          (char)214 /* byte 214 */  ,
+          (char)215 /* byte 215 */  ,
+          (char)216 /* byte 216 */  ,
+          (char)217 /* byte 217 */  ,
+          (char)218 /* byte 218 */  ,
+          (char)219 /* byte 219 */  ,
+          (char)220 /* byte 220 */  ,
+          (char)221 /* byte 221 */  ,
+          (char)222 /* byte 222 */  ,
+          (char)223 /* byte 223 */  ,
+          (char)224 /* byte 224 */  ,
+          (char)225 /* byte 225 */  ,
+          (char)226 /* byte 226 */  ,
+          (char)227 /* byte 227 */  ,
+          (char)228 /* byte 228 */  ,
+          (char)229 /* byte 229 */  ,
+          (char)230 /* byte 230 */  ,
+          (char)231 /* byte 231 */  ,
+          (char)232 /* byte 232 */  ,
+          (char)233 /* byte 233 */  ,
+          (char)234 /* byte 234 */  ,
+          (char)235 /* byte 235 */  ,
+          (char)236 /* byte 236 */  ,
+          (char)237 /* byte 237 */  ,
+          (char)238 /* byte 238 */  ,
+          (char)239 /* byte 239 */  ,
+          (char)240 /* byte 240 */  ,
+          (char)241 /* byte 241 */  ,
+          (char)242 /* byte 242 */  ,
+          (char)243 /* byte 243 */  ,
+          (char)244 /* byte 244 */  ,
+          (char)245 /* byte 245 */  ,
+          (char)246 /* byte 246 */  ,
+          (char)247 /* byte 247 */  ,
+          (char)248 /* byte 248 */  ,
+          (char)249 /* byte 249 */  ,
+          (char)250 /* byte 250 */  ,
+          (char)251 /* byte 251 */  ,
+          (char)252 /* byte 252 */  ,
+          (char)253 /* byte 253 */  ,
+          (char)254 /* byte 254 */  ,
+          (char)255 /* byte 255 */  
+        };
+
+        #endregion
+
+        #region Byte Lookup Dictionary
+
+        /// <summary>
+        /// This dictionary is used to resolve byte values for a given character.
+        /// </summary>
+        private static Dictionary<char, byte> charToByte = new Dictionary<char, byte>
+        {
+          { (char)0, 0 },
+          { (char)1, 1 },
+          { (char)2, 2 },
+          { (char)3, 3 },
+          { (char)4, 4 },
+          { (char)5, 5 },
+          { (char)6, 6 },
+          { (char)7, 7 },
+          { (char)8, 8 },
+          { (char)9, 9 },
+          { (char)10, 10 },
+          { (char)11, 11 },
+          { (char)12, 12 },
+          { (char)13, 13 },
+          { (char)14, 14 },
+          { (char)15, 15 },
+          { (char)16, 16 },
+          { (char)17, 17 },
+          { (char)18, 18 },
+          { (char)19, 19 },
+          { (char)20, 20 },
+          { (char)21, 21 },
+          { (char)22, 22 },
+          { (char)23, 23 },
+          { (char)24, 24 },
+          { (char)25, 25 },
+          { (char)26, 26 },
+          { (char)27, 27 },
+          { (char)28, 28 },
+          { (char)29, 29 },
+          { (char)30, 30 },
+          { (char)31, 31 },
+          { (char)32, 32 },
+          { (char)33, 33 },
+          { (char)34, 34 },
+          { (char)35, 35 },
+          { (char)36, 36 },
+          { (char)37, 37 },
+          { (char)38, 38 },
+          { (char)39, 39 },
+          { (char)40, 40 },
+          { (char)41, 41 },
+          { (char)42, 42 },
+          { (char)43, 43 },
+          { (char)44, 44 },
+          { (char)45, 45 },
+          { (char)46, 46 },
+          { (char)47, 47 },
+          { (char)48, 48 },
+          { (char)49, 49 },
+          { (char)50, 50 },
+          { (char)51, 51 },
+          { (char)52, 52 },
+          { (char)53, 53 },
+          { (char)54, 54 },
+          { (char)55, 55 },
+          { (char)56, 56 },
+          { (char)57, 57 },
+          { (char)58, 58 },
+          { (char)59, 59 },
+          { (char)60, 60 },
+          { (char)61, 61 },
+          { (char)62, 62 },
+          { (char)63, 63 },
+          { (char)64, 64 },
+          { (char)65, 65 },
+          { (char)66, 66 },
+          { (char)67, 67 },
+          { (char)68, 68 },
+          { (char)69, 69 },
+          { (char)70, 70 },
+          { (char)71, 71 },
+          { (char)72, 72 },
+          { (char)73, 73 },
+          { (char)74, 74 },
+          { (char)75, 75 },
+          { (char)76, 76 },
+          { (char)77, 77 },
+          { (char)78, 78 },
+          { (char)79, 79 },
+          { (char)80, 80 },
+          { (char)81, 81 },
+          { (char)82, 82 },
+          { (char)83, 83 },
+          { (char)84, 84 },
+          { (char)85, 85 },
+          { (char)86, 86 },
+          { (char)87, 87 },
+          { (char)88, 88 },
+          { (char)89, 89 },
+          { (char)90, 90 },
+          { (char)91, 91 },
+          { (char)92, 92 },
+          { (char)93, 93 },
+          { (char)94, 94 },
+          { (char)95, 95 },
+          { (char)96, 96 },
+          { (char)97, 97 },
+          { (char)98, 98 },
+          { (char)99, 99 },
+          { (char)100, 100 },
+          { (char)101, 101 },
+          { (char)102, 102 },
+          { (char)103, 103 },
+          { (char)104, 104 },
+          { (char)105, 105 },
+          { (char)106, 106 },
+          { (char)107, 107 },
+          { (char)108, 108 },
+          { (char)109, 109 },
+          { (char)110, 110 },
+          { (char)111, 111 },
+          { (char)112, 112 },
+          { (char)113, 113 },
+          { (char)114, 114 },
+          { (char)115, 115 },
+          { (char)116, 116 },
+          { (char)117, 117 },
+          { (char)118, 118 },
+          { (char)119, 119 },
+          { (char)120, 120 },
+          { (char)121, 121 },
+          { (char)122, 122 },
+          { (char)123, 123 },
+          { (char)124, 124 },
+          { (char)125, 125 },
+          { (char)126, 126 },
+          { (char)127, 127 },
+          { (char)128, 128 },
+          { (char)129, 129 },
+          { (char)130, 130 },
+          { (char)131, 131 },
+          { (char)132, 132 },
+          { (char)133, 133 },
+          { (char)134, 134 },
+          { (char)135, 135 },
+          { (char)136, 136 },
+          { (char)137, 137 },
+          { (char)138, 138 },
+          { (char)139, 139 },
+          { (char)140, 140 },
+          { (char)141, 141 },
+          { (char)142, 142 },
+          { (char)143, 143 },
+          { (char)144, 144 },
+          { (char)145, 145 },
+          { (char)146, 146 },
+          { (char)147, 147 },
+          { (char)148, 148 },
+          { (char)149, 149 },
+          { (char)150, 150 },
+          { (char)151, 151 },
+          { (char)152, 152 },
+          { (char)153, 153 },
+          { (char)154, 154 },
+          { (char)155, 155 },
+          { (char)156, 156 },
+          { (char)157, 157 },
+          { (char)158, 158 },
+          { (char)159, 159 },
+          { (char)160, 160 },
+          { (char)161, 161 },
+          { (char)162, 162 },
+          { (char)163, 163 },
+          { (char)164, 164 },
+          { (char)165, 165 },
+          { (char)166, 166 },
+          { (char)167, 167 },
+          { (char)168, 168 },
+          { (char)169, 169 },
+          { (char)170, 170 },
+          { (char)171, 171 },
+          { (char)172, 172 },
+          { (char)173, 173 },
+          { (char)174, 174 },
+          { (char)175, 175 },
+          { (char)176, 176 },
+          { (char)177, 177 },
+          { (char)178, 178 },
+          { (char)179, 179 },
+          { (char)180, 180 },
+          { (char)181, 181 },
+          { (char)182, 182 },
+          { (char)183, 183 },
+          { (char)184, 184 },
+          { (char)185, 185 },
+          { (char)186, 186 },
+          { (char)187, 187 },
+          { (char)188, 188 },
+          { (char)189, 189 },
+          { (char)190, 190 },
+          { (char)191, 191 },
+          { (char)192, 192 },
+          { (char)193, 193 },
+          { (char)194, 194 },
+          { (char)195, 195 },
+          { (char)196, 196 },
+          { (char)197, 197 },
+          { (char)198, 198 },
+          { (char)199, 199 },
+          { (char)200, 200 },
+          { (char)201, 201 },
+          { (char)202, 202 },
+          { (char)203, 203 },
+          { (char)204, 204 },
+          { (char)205, 205 },
+          { (char)206, 206 },
+          { (char)207, 207 },
+          { (char)208, 208 },
+          { (char)209, 209 },
+          { (char)210, 210 },
+          { (char)211, 211 },
+          { (char)212, 212 },
+          { (char)213, 213 },
+          { (char)214, 214 },
+          { (char)215, 215 },
+          { (char)216, 216 },
+          { (char)217, 217 },
+          { (char)218, 218 },
+          { (char)219, 219 },
+          { (char)220, 220 },
+          { (char)221, 221 },
+          { (char)222, 222 },
+          { (char)223, 223 },
+          { (char)224, 224 },
+          { (char)225, 225 },
+          { (char)226, 226 },
+          { (char)227, 227 },
+          { (char)228, 228 },
+          { (char)229, 229 },
+          { (char)230, 230 },
+          { (char)231, 231 },
+          { (char)232, 232 },
+          { (char)233, 233 },
+          { (char)234, 234 },
+          { (char)235, 235 },
+          { (char)236, 236 },
+          { (char)237, 237 },
+          { (char)238, 238 },
+          { (char)239, 239 },
+          { (char)240, 240 },
+          { (char)241, 241 },
+          { (char)242, 242 },
+          { (char)243, 243 },
+          { (char)244, 244 },
+          { (char)245, 245 },
+          { (char)246, 246 },
+          { (char)247, 247 },
+          { (char)248, 248 },
+          { (char)249, 249 },
+          { (char)250, 250 },
+          { (char)251, 251 },
+          { (char)252, 252 },
+          { (char)253, 253 },
+          { (char)254, 254 },
+          { (char)255, 255 }
+        };
+
+            #endregion
+        }
+}
diff --git a/MonoGame.Framework/Vector2.cs b/MonoGame.Framework/Vector2.cs
new file mode 100644
index 00000000000..6d0ea999568
--- /dev/null
+++ b/MonoGame.Framework/Vector2.cs
@@ -0,0 +1,1258 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Describes a 2D-vector.
+    /// </summary>
+#if XNADESIGNPROVIDED
+    [System.ComponentModel.TypeConverter(typeof(Microsoft.Xna.Framework.Design.Vector2TypeConverter))]
+#endif
+    [DataContract]
+    [DebuggerDisplay("{DebugDisplayString,nq}")]
+    public struct Vector2 : IEquatable<Vector2>
+    {
+        #region Private Fields
+
+        private static readonly Vector2 zeroVector = new Vector2(0f, 0f);
+        private static readonly Vector2 unitVector = new Vector2(1f, 1f);
+        private static readonly Vector2 unitXVector = new Vector2(1f, 0f);
+        private static readonly Vector2 unitYVector = new Vector2(0f, 1f);
+
+        #endregion
+
+        #region Public Fields
+
+        /// <summary>
+        /// The x coordinate of this <see cref="Vector2"/>.
+        /// </summary>
+        [DataMember]
+        public float X;
+
+        /// <summary>
+        /// The y coordinate of this <see cref="Vector2"/>.
+        /// </summary>
+        [DataMember]
+        public float Y;
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Returns a <see cref="Vector2"/> with components 0, 0.
+        /// </summary>
+        public static Vector2 Zero
+        {
+            get { return zeroVector; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector2"/> with components 1, 1.
+        /// </summary>
+        public static Vector2 One
+        {
+            get { return unitVector; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector2"/> with components 1, 0.
+        /// </summary>
+        public static Vector2 UnitX
+        {
+            get { return unitXVector; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector2"/> with components 0, 1.
+        /// </summary>
+        public static Vector2 UnitY
+        {
+            get { return unitYVector; }
+        }
+
+        #endregion
+
+        #region Internal Properties
+
+        internal string DebugDisplayString
+        {
+            get
+            {
+                return string.Concat(
+                    this.X.ToString(), "  ",
+                    this.Y.ToString()
+                );
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Constructs a 2d vector with X and Y from two values.
+        /// </summary>
+        /// <param name="x">The x coordinate in 2d-space.</param>
+        /// <param name="y">The y coordinate in 2d-space.</param>
+        public Vector2(float x, float y)
+        {
+            this.X = x;
+            this.Y = y;
+        }
+
+        /// <summary>
+        /// Constructs a 2d vector with X and Y set to the same value.
+        /// </summary>
+        /// <param name="value">The x and y coordinates in 2d-space.</param>
+        public Vector2(float value)
+        {
+            this.X = value;
+            this.Y = value;
+        }
+
+        #endregion
+
+        #region Operators
+
+        /// <summary>
+        /// Inverts values in the specified <see cref="Vector2"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/> on the right of the sub sign.</param>
+        /// <returns>Result of the inversion.</returns>
+        public static Vector2 operator -(Vector2 value)
+        {
+            value.X = -value.X;
+            value.Y = -value.Y;
+            return value;
+        }
+
+        /// <summary>
+        /// Adds two vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/> on the left of the add sign.</param>
+        /// <param name="value2">Source <see cref="Vector2"/> on the right of the add sign.</param>
+        /// <returns>Sum of the vectors.</returns>
+        public static Vector2 operator +(Vector2 value1, Vector2 value2)
+        {
+            value1.X += value2.X;
+            value1.Y += value2.Y;
+            return value1;
+        }
+
+        /// <summary>
+        /// Subtracts a <see cref="Vector2"/> from a <see cref="Vector2"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/> on the left of the sub sign.</param>
+        /// <param name="value2">Source <see cref="Vector2"/> on the right of the sub sign.</param>
+        /// <returns>Result of the vector subtraction.</returns>
+        public static Vector2 operator -(Vector2 value1, Vector2 value2)
+        {
+            value1.X -= value2.X;
+            value1.Y -= value2.Y;
+            return value1;
+        }
+
+        /// <summary>
+        /// Multiplies the components of two vectors by each other.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/> on the left of the mul sign.</param>
+        /// <param name="value2">Source <see cref="Vector2"/> on the right of the mul sign.</param>
+        /// <returns>Result of the vector multiplication.</returns>
+        public static Vector2 operator *(Vector2 value1, Vector2 value2)
+        {
+            value1.X *= value2.X;
+            value1.Y *= value2.Y;
+            return value1;
+        }
+
+        /// <summary>
+        /// Multiplies the components of vector by a scalar.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/> on the left of the mul sign.</param>
+        /// <param name="scaleFactor">Scalar value on the right of the mul sign.</param>
+        /// <returns>Result of the vector multiplication with a scalar.</returns>
+        public static Vector2 operator *(Vector2 value, float scaleFactor)
+        {
+            value.X *= scaleFactor;
+            value.Y *= scaleFactor;
+            return value;
+        }
+
+        /// <summary>
+        /// Multiplies the components of vector by a scalar.
+        /// </summary>
+        /// <param name="scaleFactor">Scalar value on the left of the mul sign.</param>
+        /// <param name="value">Source <see cref="Vector2"/> on the right of the mul sign.</param>
+        /// <returns>Result of the vector multiplication with a scalar.</returns>
+        public static Vector2 operator *(float scaleFactor, Vector2 value)
+        {
+            value.X *= scaleFactor;
+            value.Y *= scaleFactor;
+            return value;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector2"/> by the components of another <see cref="Vector2"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/> on the left of the div sign.</param>
+        /// <param name="value2">Divisor <see cref="Vector2"/> on the right of the div sign.</param>
+        /// <returns>The result of dividing the vectors.</returns>
+        public static Vector2 operator /(Vector2 value1, Vector2 value2)
+        {
+            value1.X /= value2.X;
+            value1.Y /= value2.Y;
+            return value1;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector2"/> by a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/> on the left of the div sign.</param>
+        /// <param name="divider">Divisor scalar on the right of the div sign.</param>
+        /// <returns>The result of dividing a vector by a scalar.</returns>
+        public static Vector2 operator /(Vector2 value1, float divider)
+        {
+            float factor = 1 / divider;
+            value1.X *= factor;
+            value1.Y *= factor;
+            return value1;
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="Vector2"/> instances are equal.
+        /// </summary>
+        /// <param name="value1"><see cref="Vector2"/> instance on the left of the equal sign.</param>
+        /// <param name="value2"><see cref="Vector2"/> instance on the right of the equal sign.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Vector2 value1, Vector2 value2)
+        {
+            return value1.X == value2.X && value1.Y == value2.Y;
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="Vector2"/> instances are not equal.
+        /// </summary>
+        /// <param name="value1"><see cref="Vector2"/> instance on the left of the not equal sign.</param>
+        /// <param name="value2"><see cref="Vector2"/> instance on the right of the not equal sign.</param>
+        /// <returns><c>true</c> if the instances are not equal; <c>false</c> otherwise.</returns>	
+        public static bool operator !=(Vector2 value1, Vector2 value2)
+        {
+            return value1.X != value2.X || value1.Y != value2.Y;
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Performs vector addition on <paramref name="value1"/> and <paramref name="value2"/>.
+        /// </summary>
+        /// <param name="value1">The first vector to add.</param>
+        /// <param name="value2">The second vector to add.</param>
+        /// <returns>The result of the vector addition.</returns>
+        public static Vector2 Add(Vector2 value1, Vector2 value2)
+        {
+            value1.X += value2.X;
+            value1.Y += value2.Y;
+            return value1;
+        }
+
+        /// <summary>
+        /// Performs vector addition on <paramref name="value1"/> and
+        /// <paramref name="value2"/>, storing the result of the
+        /// addition in <paramref name="result"/>.
+        /// </summary>
+        /// <param name="value1">The first vector to add.</param>
+        /// <param name="value2">The second vector to add.</param>
+        /// <param name="result">The result of the vector addition.</param>
+        public static void Add(ref Vector2 value1, ref Vector2 value2, out Vector2 result)
+        {
+            result.X = value1.X + value2.X;
+            result.Y = value1.Y + value2.Y;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains the cartesian coordinates of a vector specified in barycentric coordinates and relative to 2d-triangle.
+        /// </summary>
+        /// <param name="value1">The first vector of 2d-triangle.</param>
+        /// <param name="value2">The second vector of 2d-triangle.</param>
+        /// <param name="value3">The third vector of 2d-triangle.</param>
+        /// <param name="amount1">Barycentric scalar <c>b2</c> which represents a weighting factor towards second vector of 2d-triangle.</param>
+        /// <param name="amount2">Barycentric scalar <c>b3</c> which represents a weighting factor towards third vector of 2d-triangle.</param>
+        /// <returns>The cartesian translation of barycentric coordinates.</returns>
+        public static Vector2 Barycentric(Vector2 value1, Vector2 value2, Vector2 value3, float amount1, float amount2)
+        {
+            return new Vector2(
+                MathHelper.Barycentric(value1.X, value2.X, value3.X, amount1, amount2),
+                MathHelper.Barycentric(value1.Y, value2.Y, value3.Y, amount1, amount2));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains the cartesian coordinates of a vector specified in barycentric coordinates and relative to 2d-triangle.
+        /// </summary>
+        /// <param name="value1">The first vector of 2d-triangle.</param>
+        /// <param name="value2">The second vector of 2d-triangle.</param>
+        /// <param name="value3">The third vector of 2d-triangle.</param>
+        /// <param name="amount1">Barycentric scalar <c>b2</c> which represents a weighting factor towards second vector of 2d-triangle.</param>
+        /// <param name="amount2">Barycentric scalar <c>b3</c> which represents a weighting factor towards third vector of 2d-triangle.</param>
+        /// <param name="result">The cartesian translation of barycentric coordinates as an output parameter.</param>
+        public static void Barycentric(ref Vector2 value1, ref Vector2 value2, ref Vector2 value3, float amount1, float amount2, out Vector2 result)
+        {
+            result.X = MathHelper.Barycentric(value1.X, value2.X, value3.X, amount1, amount2);
+            result.Y = MathHelper.Barycentric(value1.Y, value2.Y, value3.Y, amount1, amount2);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains CatmullRom interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">The first vector in interpolation.</param>
+        /// <param name="value2">The second vector in interpolation.</param>
+        /// <param name="value3">The third vector in interpolation.</param>
+        /// <param name="value4">The fourth vector in interpolation.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <returns>The result of CatmullRom interpolation.</returns>
+        public static Vector2 CatmullRom(Vector2 value1, Vector2 value2, Vector2 value3, Vector2 value4, float amount)
+        {
+            return new Vector2(
+                MathHelper.CatmullRom(value1.X, value2.X, value3.X, value4.X, amount),
+                MathHelper.CatmullRom(value1.Y, value2.Y, value3.Y, value4.Y, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains CatmullRom interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">The first vector in interpolation.</param>
+        /// <param name="value2">The second vector in interpolation.</param>
+        /// <param name="value3">The third vector in interpolation.</param>
+        /// <param name="value4">The fourth vector in interpolation.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <param name="result">The result of CatmullRom interpolation as an output parameter.</param>
+        public static void CatmullRom(ref Vector2 value1, ref Vector2 value2, ref Vector2 value3, ref Vector2 value4, float amount, out Vector2 result)
+        {
+            result.X = MathHelper.CatmullRom(value1.X, value2.X, value3.X, value4.X, amount);
+            result.Y = MathHelper.CatmullRom(value1.Y, value2.Y, value3.Y, value4.Y, amount);
+        }
+
+        /// <summary>
+        /// Round the members of this <see cref="Vector2"/> towards positive infinity.
+        /// </summary>
+        public void Ceiling()
+        {
+            X = (float)Math.Ceiling(X);
+            Y = (float)Math.Ceiling(Y);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains members from another vector rounded towards positive infinity.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <returns>The rounded <see cref="Vector2"/>.</returns>
+        public static Vector2 Ceiling(Vector2 value)
+        {
+            value.X = (float)Math.Ceiling(value.X);
+            value.Y = (float)Math.Ceiling(value.Y);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains members from another vector rounded towards positive infinity.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <param name="result">The rounded <see cref="Vector2"/>.</param>
+        public static void Ceiling(ref Vector2 value, out Vector2 result)
+        {
+            result.X = (float)Math.Ceiling(value.X);
+            result.Y = (float)Math.Ceiling(value.Y);
+        }
+
+        /// <summary>
+        /// Clamps the specified value within a range.
+        /// </summary>
+        /// <param name="value1">The value to clamp.</param>
+        /// <param name="min">The min value.</param>
+        /// <param name="max">The max value.</param>
+        /// <returns>The clamped value.</returns>
+        public static Vector2 Clamp(Vector2 value1, Vector2 min, Vector2 max)
+        {
+            return new Vector2(
+                MathHelper.Clamp(value1.X, min.X, max.X),
+                MathHelper.Clamp(value1.Y, min.Y, max.Y));
+        }
+
+        /// <summary>
+        /// Clamps the specified value within a range.
+        /// </summary>
+        /// <param name="value1">The value to clamp.</param>
+        /// <param name="min">The min value.</param>
+        /// <param name="max">The max value.</param>
+        /// <param name="result">The clamped value as an output parameter.</param>
+        public static void Clamp(ref Vector2 value1, ref Vector2 min, ref Vector2 max, out Vector2 result)
+        {
+            result.X = MathHelper.Clamp(value1.X, min.X, max.X);
+            result.Y = MathHelper.Clamp(value1.Y, min.Y, max.Y);
+        }
+
+        /// <summary>
+        /// Returns the distance between two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The distance between two vectors.</returns>
+        public static float Distance(Vector2 value1, Vector2 value2)
+        {
+            float v1 = value1.X - value2.X, v2 = value1.Y - value2.Y;
+            return (float)Math.Sqrt((v1 * v1) + (v2 * v2));
+        }
+
+        /// <summary>
+        /// Returns the distance between two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The distance between two vectors as an output parameter.</param>
+        public static void Distance(ref Vector2 value1, ref Vector2 value2, out float result)
+        {
+            float v1 = value1.X - value2.X, v2 = value1.Y - value2.Y;
+            result = (float)Math.Sqrt((v1 * v1) + (v2 * v2));
+        }
+
+        /// <summary>
+        /// Returns the squared distance between two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The squared distance between two vectors.</returns>
+        public static float DistanceSquared(Vector2 value1, Vector2 value2)
+        {
+            float v1 = value1.X - value2.X, v2 = value1.Y - value2.Y;
+            return (v1 * v1) + (v2 * v2);
+        }
+
+        /// <summary>
+        /// Returns the squared distance between two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The squared distance between two vectors as an output parameter.</param>
+        public static void DistanceSquared(ref Vector2 value1, ref Vector2 value2, out float result)
+        {
+            float v1 = value1.X - value2.X, v2 = value1.Y - value2.Y;
+            result = (v1 * v1) + (v2 * v2);
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector2"/> by the components of another <see cref="Vector2"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/>.</param>
+        /// <param name="value2">Divisor <see cref="Vector2"/>.</param>
+        /// <returns>The result of dividing the vectors.</returns>
+        public static Vector2 Divide(Vector2 value1, Vector2 value2)
+        {
+            value1.X /= value2.X;
+            value1.Y /= value2.Y;
+            return value1;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector2"/> by the components of another <see cref="Vector2"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/>.</param>
+        /// <param name="value2">Divisor <see cref="Vector2"/>.</param>
+        /// <param name="result">The result of dividing the vectors as an output parameter.</param>
+        public static void Divide(ref Vector2 value1, ref Vector2 value2, out Vector2 result)
+        {
+            result.X = value1.X / value2.X;
+            result.Y = value1.Y / value2.Y;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector2"/> by a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/>.</param>
+        /// <param name="divider">Divisor scalar.</param>
+        /// <returns>The result of dividing a vector by a scalar.</returns>
+        public static Vector2 Divide(Vector2 value1, float divider)
+        {
+            float factor = 1 / divider;
+            value1.X *= factor;
+            value1.Y *= factor;
+            return value1;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector2"/> by a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/>.</param>
+        /// <param name="divider">Divisor scalar.</param>
+        /// <param name="result">The result of dividing a vector by a scalar as an output parameter.</param>
+        public static void Divide(ref Vector2 value1, float divider, out Vector2 result)
+        {
+            float factor = 1 / divider;
+            result.X = value1.X * factor;
+            result.Y = value1.Y * factor;
+        }
+
+        /// <summary>
+        /// Returns a dot product of two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The dot product of two vectors.</returns>
+        public static float Dot(Vector2 value1, Vector2 value2)
+        {
+            return (value1.X * value2.X) + (value1.Y * value2.Y);
+        }
+
+        /// <summary>
+        /// Returns a dot product of two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The dot product of two vectors as an output parameter.</param>
+        public static void Dot(ref Vector2 value1, ref Vector2 value2, out float result)
+        {
+            result = (value1.X * value2.X) + (value1.Y * value2.Y);
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Object"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="Object"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            if (obj is Vector2)
+            {
+                return Equals((Vector2)obj);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Vector2"/>.
+        /// </summary>
+        /// <param name="other">The <see cref="Vector2"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public bool Equals(Vector2 other)
+        {
+            return (X == other.X) && (Y == other.Y);
+        }
+
+        /// <summary>
+        /// Round the members of this <see cref="Vector2"/> towards negative infinity.
+        /// </summary>
+        public void Floor()
+        {
+            X = (float)Math.Floor(X);
+            Y = (float)Math.Floor(Y);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains members from another vector rounded towards negative infinity.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <returns>The rounded <see cref="Vector2"/>.</returns>
+        public static Vector2 Floor(Vector2 value)
+        {
+            value.X = (float)Math.Floor(value.X);
+            value.Y = (float)Math.Floor(value.Y);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains members from another vector rounded towards negative infinity.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <param name="result">The rounded <see cref="Vector2"/>.</param>
+        public static void Floor(ref Vector2 value, out Vector2 result)
+        {
+            result.X = (float)Math.Floor(value.X);
+            result.Y = (float)Math.Floor(value.Y);
+        }
+
+        /// <summary>
+        /// Gets the hash code of this <see cref="Vector2"/>.
+        /// </summary>
+        /// <returns>Hash code of this <see cref="Vector2"/>.</returns>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (X.GetHashCode() * 397) ^ Y.GetHashCode();
+            }
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains hermite spline interpolation.
+        /// </summary>
+        /// <param name="value1">The first position vector.</param>
+        /// <param name="tangent1">The first tangent vector.</param>
+        /// <param name="value2">The second position vector.</param>
+        /// <param name="tangent2">The second tangent vector.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <returns>The hermite spline interpolation vector.</returns>
+        public static Vector2 Hermite(Vector2 value1, Vector2 tangent1, Vector2 value2, Vector2 tangent2, float amount)
+        {
+            return new Vector2(MathHelper.Hermite(value1.X, tangent1.X, value2.X, tangent2.X, amount), MathHelper.Hermite(value1.Y, tangent1.Y, value2.Y, tangent2.Y, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains hermite spline interpolation.
+        /// </summary>
+        /// <param name="value1">The first position vector.</param>
+        /// <param name="tangent1">The first tangent vector.</param>
+        /// <param name="value2">The second position vector.</param>
+        /// <param name="tangent2">The second tangent vector.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <param name="result">The hermite spline interpolation vector as an output parameter.</param>
+        public static void Hermite(ref Vector2 value1, ref Vector2 tangent1, ref Vector2 value2, ref Vector2 tangent2, float amount, out Vector2 result)
+        {
+            result.X = MathHelper.Hermite(value1.X, tangent1.X, value2.X, tangent2.X, amount);
+            result.Y = MathHelper.Hermite(value1.Y, tangent1.Y, value2.Y, tangent2.Y, amount);
+        }
+
+        /// <summary>
+        /// Returns the length of this <see cref="Vector2"/>.
+        /// </summary>
+        /// <returns>The length of this <see cref="Vector2"/>.</returns>
+        public float Length()
+        {
+            return (float)Math.Sqrt((X * X) + (Y * Y));
+        }
+
+        /// <summary>
+        /// Returns the squared length of this <see cref="Vector2"/>.
+        /// </summary>
+        /// <returns>The squared length of this <see cref="Vector2"/>.</returns>
+        public float LengthSquared()
+        {
+            return (X * X) + (Y * Y);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains linear interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <returns>The result of linear interpolation of the specified vectors.</returns>
+        public static Vector2 Lerp(Vector2 value1, Vector2 value2, float amount)
+        {
+            return new Vector2(
+                MathHelper.Lerp(value1.X, value2.X, amount),
+                MathHelper.Lerp(value1.Y, value2.Y, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains linear interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <param name="result">The result of linear interpolation of the specified vectors as an output parameter.</param>
+        public static void Lerp(ref Vector2 value1, ref Vector2 value2, float amount, out Vector2 result)
+        {
+            result.X = MathHelper.Lerp(value1.X, value2.X, amount);
+            result.Y = MathHelper.Lerp(value1.Y, value2.Y, amount);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains linear interpolation of the specified vectors.
+        /// Uses <see cref="MathHelper.LerpPrecise"/> on MathHelper for the interpolation.
+        /// Less efficient but more precise compared to <see cref="Vector2.Lerp(Vector2, Vector2, float)"/>.
+        /// See remarks section of <see cref="MathHelper.LerpPrecise"/> on MathHelper for more info.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <returns>The result of linear interpolation of the specified vectors.</returns>
+        public static Vector2 LerpPrecise(Vector2 value1, Vector2 value2, float amount)
+        {
+            return new Vector2(
+                MathHelper.LerpPrecise(value1.X, value2.X, amount),
+                MathHelper.LerpPrecise(value1.Y, value2.Y, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains linear interpolation of the specified vectors.
+        /// Uses <see cref="MathHelper.LerpPrecise"/> on MathHelper for the interpolation.
+        /// Less efficient but more precise compared to <see cref="Vector2.Lerp(ref Vector2, ref Vector2, float, out Vector2)"/>.
+        /// See remarks section of <see cref="MathHelper.LerpPrecise"/> on MathHelper for more info.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <param name="result">The result of linear interpolation of the specified vectors as an output parameter.</param>
+        public static void LerpPrecise(ref Vector2 value1, ref Vector2 value2, float amount, out Vector2 result)
+        { 
+            result.X = MathHelper.LerpPrecise(value1.X, value2.X, amount);
+            result.Y = MathHelper.LerpPrecise(value1.Y, value2.Y, amount);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a maximal values from the two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The <see cref="Vector2"/> with maximal values from the two vectors.</returns>
+        public static Vector2 Max(Vector2 value1, Vector2 value2)
+        {
+            return new Vector2(value1.X > value2.X ? value1.X : value2.X,
+                               value1.Y > value2.Y ? value1.Y : value2.Y);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a maximal values from the two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The <see cref="Vector2"/> with maximal values from the two vectors as an output parameter.</param>
+        public static void Max(ref Vector2 value1, ref Vector2 value2, out Vector2 result)
+        {
+            result.X = value1.X > value2.X ? value1.X : value2.X;
+            result.Y = value1.Y > value2.Y ? value1.Y : value2.Y;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a minimal values from the two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The <see cref="Vector2"/> with minimal values from the two vectors.</returns>
+        public static Vector2 Min(Vector2 value1, Vector2 value2)
+        {
+            return new Vector2(value1.X < value2.X ? value1.X : value2.X,
+                               value1.Y < value2.Y ? value1.Y : value2.Y);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a minimal values from the two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The <see cref="Vector2"/> with minimal values from the two vectors as an output parameter.</param>
+        public static void Min(ref Vector2 value1, ref Vector2 value2, out Vector2 result)
+        {
+            result.X = value1.X < value2.X ? value1.X : value2.X;
+            result.Y = value1.Y < value2.Y ? value1.Y : value2.Y;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a multiplication of two vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/>.</param>
+        /// <param name="value2">Source <see cref="Vector2"/>.</param>
+        /// <returns>The result of the vector multiplication.</returns>
+        public static Vector2 Multiply(Vector2 value1, Vector2 value2)
+        {
+            value1.X *= value2.X;
+            value1.Y *= value2.Y;
+            return value1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a multiplication of two vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/>.</param>
+        /// <param name="value2">Source <see cref="Vector2"/>.</param>
+        /// <param name="result">The result of the vector multiplication as an output parameter.</param>
+        public static void Multiply(ref Vector2 value1, ref Vector2 value2, out Vector2 result)
+        {
+            result.X = value1.X * value2.X;
+            result.Y = value1.Y * value2.Y;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a multiplication of <see cref="Vector2"/> and a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/>.</param>
+        /// <param name="scaleFactor">Scalar value.</param>
+        /// <returns>The result of the vector multiplication with a scalar.</returns>
+        public static Vector2 Multiply(Vector2 value1, float scaleFactor)
+        {
+            value1.X *= scaleFactor;
+            value1.Y *= scaleFactor;
+            return value1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a multiplication of <see cref="Vector2"/> and a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/>.</param>
+        /// <param name="scaleFactor">Scalar value.</param>
+        /// <param name="result">The result of the multiplication with a scalar as an output parameter.</param>
+        public static void Multiply(ref Vector2 value1, float scaleFactor, out Vector2 result)
+        {
+            result.X = value1.X * scaleFactor;
+            result.Y = value1.Y * scaleFactor;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains the specified vector inversion.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <returns>The result of the vector inversion.</returns>
+        public static Vector2 Negate(Vector2 value)
+        {
+            value.X = -value.X;
+            value.Y = -value.Y;
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains the specified vector inversion.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <param name="result">The result of the vector inversion as an output parameter.</param>
+        public static void Negate(ref Vector2 value, out Vector2 result)
+        {
+            result.X = -value.X;
+            result.Y = -value.Y;
+        }
+
+        /// <summary>
+        /// Turns this <see cref="Vector2"/> to a unit vector with the same direction.
+        /// </summary>
+        public void Normalize()
+        {
+            float val = 1.0f / (float)Math.Sqrt((X * X) + (Y * Y));
+            X *= val;
+            Y *= val;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a normalized values from another vector.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <returns>Unit vector.</returns>
+        public static Vector2 Normalize(Vector2 value)
+        {
+            float val = 1.0f / (float)Math.Sqrt((value.X * value.X) + (value.Y * value.Y));
+            value.X *= val;
+            value.Y *= val;
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a normalized values from another vector.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <param name="result">Unit vector as an output parameter.</param>
+        public static void Normalize(ref Vector2 value, out Vector2 result)
+        {
+            float val = 1.0f / (float)Math.Sqrt((value.X * value.X) + (value.Y * value.Y));
+            result.X = value.X * val;
+            result.Y = value.Y * val;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains reflect vector of the given vector and normal.
+        /// </summary>
+        /// <param name="vector">Source <see cref="Vector2"/>.</param>
+        /// <param name="normal">Reflection normal.</param>
+        /// <returns>Reflected vector.</returns>
+        public static Vector2 Reflect(Vector2 vector, Vector2 normal)
+        {
+            Vector2 result;
+            float val = 2.0f * ((vector.X * normal.X) + (vector.Y * normal.Y));
+            result.X = vector.X - (normal.X * val);
+            result.Y = vector.Y - (normal.Y * val);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains reflect vector of the given vector and normal.
+        /// </summary>
+        /// <param name="vector">Source <see cref="Vector2"/>.</param>
+        /// <param name="normal">Reflection normal.</param>
+        /// <param name="result">Reflected vector as an output parameter.</param>
+        public static void Reflect(ref Vector2 vector, ref Vector2 normal, out Vector2 result)
+        {
+            float val = 2.0f * ((vector.X * normal.X) + (vector.Y * normal.Y));
+            result.X = vector.X - (normal.X * val);
+            result.Y = vector.Y - (normal.Y * val);
+        }
+
+        /// <summary>
+        /// Round the members of this <see cref="Vector2"/> to the nearest integer value.
+        /// </summary>
+        public void Round()
+        {
+            X = (float)Math.Round(X);
+            Y = (float)Math.Round(Y);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains members from another vector rounded to the nearest integer value.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <returns>The rounded <see cref="Vector2"/>.</returns>
+        public static Vector2 Round(Vector2 value)
+        {
+            value.X = (float)Math.Round(value.X);
+            value.Y = (float)Math.Round(value.Y);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains members from another vector rounded to the nearest integer value.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <param name="result">The rounded <see cref="Vector2"/>.</param>
+        public static void Round(ref Vector2 value, out Vector2 result)
+        {
+            result.X = (float)Math.Round(value.X);
+            result.Y = (float)Math.Round(value.Y);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains cubic interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/>.</param>
+        /// <param name="value2">Source <see cref="Vector2"/>.</param>
+        /// <param name="amount">Weighting value.</param>
+        /// <returns>Cubic interpolation of the specified vectors.</returns>
+        public static Vector2 SmoothStep(Vector2 value1, Vector2 value2, float amount)
+        {
+            return new Vector2(
+                MathHelper.SmoothStep(value1.X, value2.X, amount),
+                MathHelper.SmoothStep(value1.Y, value2.Y, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains cubic interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/>.</param>
+        /// <param name="value2">Source <see cref="Vector2"/>.</param>
+        /// <param name="amount">Weighting value.</param>
+        /// <param name="result">Cubic interpolation of the specified vectors as an output parameter.</param>
+        public static void SmoothStep(ref Vector2 value1, ref Vector2 value2, float amount, out Vector2 result)
+        {
+            result.X = MathHelper.SmoothStep(value1.X, value2.X, amount);
+            result.Y = MathHelper.SmoothStep(value1.Y, value2.Y, amount);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains subtraction of on <see cref="Vector2"/> from a another.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/>.</param>
+        /// <param name="value2">Source <see cref="Vector2"/>.</param>
+        /// <returns>The result of the vector subtraction.</returns>
+        public static Vector2 Subtract(Vector2 value1, Vector2 value2)
+        {
+            value1.X -= value2.X;
+            value1.Y -= value2.Y;
+            return value1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains subtraction of on <see cref="Vector2"/> from a another.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector2"/>.</param>
+        /// <param name="value2">Source <see cref="Vector2"/>.</param>
+        /// <param name="result">The result of the vector subtraction as an output parameter.</param>
+        public static void Subtract(ref Vector2 value1, ref Vector2 value2, out Vector2 result)
+        {
+            result.X = value1.X - value2.X;
+            result.Y = value1.Y - value2.Y;
+        }
+
+        /// <summary>
+        /// Returns a <see cref="String"/> representation of this <see cref="Vector2"/> in the format:
+        /// {X:[<see cref="X"/>] Y:[<see cref="Y"/>]}
+        /// </summary>
+        /// <returns>A <see cref="String"/> representation of this <see cref="Vector2"/>.</returns>
+        public override string ToString()
+        {
+            return "{X:" + X + " Y:" + Y + "}";
+        }
+
+        /// <summary>
+        /// Gets a <see cref="Point"/> representation for this object.
+        /// </summary>
+        /// <returns>A <see cref="Point"/> representation for this object.</returns>
+        public Point ToPoint()
+        {
+            return new Point((int) X,(int) Y);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a transformation of 2d-vector by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="position">Source <see cref="Vector2"/>.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <returns>Transformed <see cref="Vector2"/>.</returns>
+        public static Vector2 Transform(Vector2 position, Matrix matrix)
+        {
+            return new Vector2((position.X * matrix.M11) + (position.Y * matrix.M21) + matrix.M41, (position.X * matrix.M12) + (position.Y * matrix.M22) + matrix.M42);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a transformation of 2d-vector by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="position">Source <see cref="Vector2"/>.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="result">Transformed <see cref="Vector2"/> as an output parameter.</param>
+        public static void Transform(ref Vector2 position, ref Matrix matrix, out Vector2 result)
+        {
+            var x = (position.X * matrix.M11) + (position.Y * matrix.M21) + matrix.M41;
+            var y = (position.X * matrix.M12) + (position.Y * matrix.M22) + matrix.M42;
+            result.X = x;
+            result.Y = y;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a transformation of 2d-vector by the specified <see cref="Quaternion"/>, representing the rotation.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <returns>Transformed <see cref="Vector2"/>.</returns>
+        public static Vector2 Transform(Vector2 value, Quaternion rotation)
+        {
+            Transform(ref value, ref rotation, out value);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a transformation of 2d-vector by the specified <see cref="Quaternion"/>, representing the rotation.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <param name="result">Transformed <see cref="Vector2"/> as an output parameter.</param>
+        public static void Transform(ref Vector2 value, ref Quaternion rotation, out Vector2 result)
+        {
+            var rot1 = new Vector3(rotation.X + rotation.X, rotation.Y + rotation.Y, rotation.Z + rotation.Z);
+            var rot2 = new Vector3(rotation.X, rotation.X, rotation.W);
+            var rot3 = new Vector3(1, rotation.Y, rotation.Z);
+            var rot4 = rot1*rot2;
+            var rot5 = rot1*rot3;
+
+            var v = new Vector2();
+            v.X = (float)((double)value.X * (1.0 - (double)rot5.Y - (double)rot5.Z) + (double)value.Y * ((double)rot4.Y - (double)rot4.Z));
+            v.Y = (float)((double)value.X * ((double)rot4.Y + (double)rot4.Z) + (double)value.Y * (1.0 - (double)rot4.X - (double)rot5.Z));
+            result.X = v.X;
+            result.Y = v.Y;
+        }
+
+        /// <summary>
+        /// Apply transformation on vectors within array of <see cref="Vector2"/> by the specified <see cref="Matrix"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="sourceIndex">The starting index of transformation in the source array.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        /// <param name="destinationIndex">The starting index in the destination array, where the first <see cref="Vector2"/> should be written.</param>
+        /// <param name="length">The number of vectors to be transformed.</param>
+        public static void Transform(
+            Vector2[] sourceArray,
+            int sourceIndex,
+            ref Matrix matrix,
+            Vector2[] destinationArray,
+            int destinationIndex,
+            int length)
+        {
+            if (sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if (sourceArray.Length < sourceIndex + length)
+                throw new ArgumentException("Source array length is lesser than sourceIndex + length");
+            if (destinationArray.Length < destinationIndex + length)
+                throw new ArgumentException("Destination array length is lesser than destinationIndex + length");
+
+            for (int x = 0; x < length; x++)
+            {
+                var position = sourceArray[sourceIndex + x];
+                var destination = destinationArray[destinationIndex + x];
+                destination.X = (position.X * matrix.M11) + (position.Y * matrix.M21) + matrix.M41;
+                destination.Y = (position.X * matrix.M12) + (position.Y * matrix.M22) + matrix.M42;
+                destinationArray[destinationIndex + x] = destination;
+            }
+        }
+
+        /// <summary>
+        /// Apply transformation on vectors within array of <see cref="Vector2"/> by the specified <see cref="Quaternion"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="sourceIndex">The starting index of transformation in the source array.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        /// <param name="destinationIndex">The starting index in the destination array, where the first <see cref="Vector2"/> should be written.</param>
+        /// <param name="length">The number of vectors to be transformed.</param>
+        public static void Transform
+        (
+            Vector2[] sourceArray,
+            int sourceIndex,
+            ref Quaternion rotation,
+            Vector2[] destinationArray,
+            int destinationIndex,
+            int length
+        )
+        {
+            if (sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if (sourceArray.Length < sourceIndex + length)
+                throw new ArgumentException("Source array length is lesser than sourceIndex + length");
+            if (destinationArray.Length < destinationIndex + length)
+                throw new ArgumentException("Destination array length is lesser than destinationIndex + length");
+
+            for (int x = 0; x < length; x++)
+            {
+                var position = sourceArray[sourceIndex + x];
+                var destination = destinationArray[destinationIndex + x];
+
+                Vector2 v;
+                Transform(ref position,ref rotation,out v); 
+
+                destination.X = v.X;
+                destination.Y = v.Y;
+
+                destinationArray[destinationIndex + x] = destination;
+            }
+        }
+
+        /// <summary>
+        /// Apply transformation on all vectors within array of <see cref="Vector2"/> by the specified <see cref="Matrix"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        public static void Transform(
+            Vector2[] sourceArray,
+            ref Matrix matrix,
+            Vector2[] destinationArray)
+        {
+            Transform(sourceArray, 0, ref matrix, destinationArray, 0, sourceArray.Length);
+        }
+
+        /// <summary>
+        /// Apply transformation on all vectors within array of <see cref="Vector2"/> by the specified <see cref="Quaternion"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        public static void Transform
+        (
+            Vector2[] sourceArray,
+            ref Quaternion rotation,
+            Vector2[] destinationArray
+        )
+        {
+            Transform(sourceArray, 0, ref rotation, destinationArray, 0, sourceArray.Length);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a transformation of the specified normal by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="normal">Source <see cref="Vector2"/> which represents a normal vector.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <returns>Transformed normal.</returns>
+        public static Vector2 TransformNormal(Vector2 normal, Matrix matrix)
+        {
+            return new Vector2((normal.X * matrix.M11) + (normal.Y * matrix.M21),(normal.X * matrix.M12) + (normal.Y * matrix.M22));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector2"/> that contains a transformation of the specified normal by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="normal">Source <see cref="Vector2"/> which represents a normal vector.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="result">Transformed normal as an output parameter.</param>
+        public static void TransformNormal(ref Vector2 normal, ref Matrix matrix, out Vector2 result)
+        {
+            var x = (normal.X * matrix.M11) + (normal.Y * matrix.M21);
+            var y = (normal.X * matrix.M12) + (normal.Y * matrix.M22);
+            result.X = x;
+            result.Y = y;
+        }
+
+        /// <summary>
+        /// Apply transformation on normals within array of <see cref="Vector2"/> by the specified <see cref="Matrix"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="sourceIndex">The starting index of transformation in the source array.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        /// <param name="destinationIndex">The starting index in the destination array, where the first <see cref="Vector2"/> should be written.</param>
+        /// <param name="length">The number of normals to be transformed.</param>
+        public static void TransformNormal
+        (
+            Vector2[] sourceArray,
+            int sourceIndex,
+            ref Matrix matrix,
+            Vector2[] destinationArray,
+            int destinationIndex,
+            int length
+        )
+        {
+            if (sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if (sourceArray.Length < sourceIndex + length)
+                throw new ArgumentException("Source array length is lesser than sourceIndex + length");
+            if (destinationArray.Length < destinationIndex + length)
+                throw new ArgumentException("Destination array length is lesser than destinationIndex + length");
+
+            for (int i = 0; i < length; i++)
+            {
+                var normal = sourceArray[sourceIndex + i];
+
+                destinationArray[destinationIndex + i] = new Vector2((normal.X * matrix.M11) + (normal.Y * matrix.M21),
+                                                                     (normal.X * matrix.M12) + (normal.Y * matrix.M22));
+            }
+        }
+
+        /// <summary>
+        /// Apply transformation on all normals within array of <see cref="Vector2"/> by the specified <see cref="Matrix"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        public static void TransformNormal
+            (
+            Vector2[] sourceArray,
+            ref Matrix matrix,
+            Vector2[] destinationArray
+            )
+        {
+            if (sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if (destinationArray.Length < sourceArray.Length)
+                throw new ArgumentException("Destination array length is lesser than source array length");
+
+            for (int i = 0; i < sourceArray.Length; i++)
+            {
+                var normal = sourceArray[i];
+
+                destinationArray[i] = new Vector2((normal.X * matrix.M11) + (normal.Y * matrix.M21),
+                                                  (normal.X * matrix.M12) + (normal.Y * matrix.M22));
+            }
+        }
+
+        /// <summary>
+        /// Deconstruction method for <see cref="Vector2"/>.
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        public void Deconstruct(out float x, out float y)
+        {
+            x = X;
+            y = Y;
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Vector3.cs b/MonoGame.Framework/Vector3.cs
new file mode 100644
index 00000000000..dbb57920132
--- /dev/null
+++ b/MonoGame.Framework/Vector3.cs
@@ -0,0 +1,1478 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using System.Text;
+using System.Runtime.Serialization;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Describes a 3D-vector.
+    /// </summary>
+#if XNADESIGNPROVIDED
+    [System.ComponentModel.TypeConverter(typeof(Microsoft.Xna.Framework.Design.Vector3TypeConverter))]
+#endif
+    [DataContract]
+    [DebuggerDisplay("{DebugDisplayString,nq}")]
+    public struct Vector3 : IEquatable<Vector3>
+    {
+        #region Private Fields
+
+        private static readonly Vector3 zero = new Vector3(0f, 0f, 0f);
+        private static readonly Vector3 one = new Vector3(1f, 1f, 1f);
+        private static readonly Vector3 unitX = new Vector3(1f, 0f, 0f);
+        private static readonly Vector3 unitY = new Vector3(0f, 1f, 0f);
+        private static readonly Vector3 unitZ = new Vector3(0f, 0f, 1f);
+        private static readonly Vector3 up = new Vector3(0f, 1f, 0f);
+        private static readonly Vector3 down = new Vector3(0f, -1f, 0f);
+        private static readonly Vector3 right = new Vector3(1f, 0f, 0f);
+        private static readonly Vector3 left = new Vector3(-1f, 0f, 0f);
+        private static readonly Vector3 forward = new Vector3(0f, 0f, -1f);
+        private static readonly Vector3 backward = new Vector3(0f, 0f, 1f);
+
+        #endregion
+
+        #region Public Fields
+
+        /// <summary>
+        /// The x coordinate of this <see cref="Vector3"/>.
+        /// </summary>
+        [DataMember]
+        public float X;
+
+        /// <summary>
+        /// The y coordinate of this <see cref="Vector3"/>.
+        /// </summary>
+        [DataMember]
+        public float Y;
+
+        /// <summary>
+        /// The z coordinate of this <see cref="Vector3"/>.
+        /// </summary>
+        [DataMember]
+        public float Z;
+
+        #endregion
+
+        #region Public Properties
+
+        /// <summary>
+        /// Returns a <see cref="Vector3"/> with components 0, 0, 0.
+        /// </summary>
+        public static Vector3 Zero
+        {
+            get { return zero; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector3"/> with components 1, 1, 1.
+        /// </summary>
+        public static Vector3 One
+        {
+            get { return one; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector3"/> with components 1, 0, 0.
+        /// </summary>
+        public static Vector3 UnitX
+        {
+            get { return unitX; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector3"/> with components 0, 1, 0.
+        /// </summary>
+        public static Vector3 UnitY
+        {
+            get { return unitY; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector3"/> with components 0, 0, 1.
+        /// </summary>
+        public static Vector3 UnitZ
+        {
+            get { return unitZ; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector3"/> with components 0, 1, 0.
+        /// </summary>
+        public static Vector3 Up
+        {
+            get { return up; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector3"/> with components 0, -1, 0.
+        /// </summary>
+        public static Vector3 Down
+        {
+            get { return down; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector3"/> with components 1, 0, 0.
+        /// </summary>
+        public static Vector3 Right
+        {
+            get { return right; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector3"/> with components -1, 0, 0.
+        /// </summary>
+        public static Vector3 Left
+        {
+            get { return left; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector3"/> with components 0, 0, -1.
+        /// </summary>
+        public static Vector3 Forward
+        {
+            get { return forward; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector3"/> with components 0, 0, 1.
+        /// </summary>
+        public static Vector3 Backward
+        {
+            get { return backward; }
+        }
+
+        #endregion
+
+        #region Internal Properties
+
+        internal string DebugDisplayString
+        {
+            get
+            {
+                return string.Concat(
+                    this.X.ToString(), "  ",
+                    this.Y.ToString(), "  ",
+                    this.Z.ToString()
+                );
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Constructs a 3d vector with X, Y and Z from three values.
+        /// </summary>
+        /// <param name="x">The x coordinate in 3d-space.</param>
+        /// <param name="y">The y coordinate in 3d-space.</param>
+        /// <param name="z">The z coordinate in 3d-space.</param>
+        public Vector3(float x, float y, float z)
+        {
+            this.X = x;
+            this.Y = y;
+            this.Z = z;
+        }
+
+        /// <summary>
+        /// Constructs a 3d vector with X, Y and Z set to the same value.
+        /// </summary>
+        /// <param name="value">The x, y and z coordinates in 3d-space.</param>
+        public Vector3(float value)
+        {
+            this.X = value;
+            this.Y = value;
+            this.Z = value;
+        }
+
+        /// <summary>
+        /// Constructs a 3d vector with X, Y from <see cref="Vector2"/> and Z from a scalar.
+        /// </summary>
+        /// <param name="value">The x and y coordinates in 3d-space.</param>
+        /// <param name="z">The z coordinate in 3d-space.</param>
+        public Vector3(Vector2 value, float z)
+        {
+            this.X = value.X;
+            this.Y = value.Y;
+            this.Z = z;
+        }
+        
+        #endregion
+        
+        #region Public Methods
+
+        /// <summary>
+        /// Performs vector addition on <paramref name="value1"/> and <paramref name="value2"/>.
+        /// </summary>
+        /// <param name="value1">The first vector to add.</param>
+        /// <param name="value2">The second vector to add.</param>
+        /// <returns>The result of the vector addition.</returns>
+        public static Vector3 Add(Vector3 value1, Vector3 value2)
+        {
+            value1.X += value2.X;
+            value1.Y += value2.Y;
+            value1.Z += value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Performs vector addition on <paramref name="value1"/> and
+        /// <paramref name="value2"/>, storing the result of the
+        /// addition in <paramref name="result"/>.
+        /// </summary>
+        /// <param name="value1">The first vector to add.</param>
+        /// <param name="value2">The second vector to add.</param>
+        /// <param name="result">The result of the vector addition.</param>
+        public static void Add(ref Vector3 value1, ref Vector3 value2, out Vector3 result)
+        {
+            result.X = value1.X + value2.X;
+            result.Y = value1.Y + value2.Y;
+            result.Z = value1.Z + value2.Z;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains the cartesian coordinates of a vector specified in barycentric coordinates and relative to 3d-triangle.
+        /// </summary>
+        /// <param name="value1">The first vector of 3d-triangle.</param>
+        /// <param name="value2">The second vector of 3d-triangle.</param>
+        /// <param name="value3">The third vector of 3d-triangle.</param>
+        /// <param name="amount1">Barycentric scalar <c>b2</c> which represents a weighting factor towards second vector of 3d-triangle.</param>
+        /// <param name="amount2">Barycentric scalar <c>b3</c> which represents a weighting factor towards third vector of 3d-triangle.</param>
+        /// <returns>The cartesian translation of barycentric coordinates.</returns>
+        public static Vector3 Barycentric(Vector3 value1, Vector3 value2, Vector3 value3, float amount1, float amount2)
+        {
+            return new Vector3(
+                MathHelper.Barycentric(value1.X, value2.X, value3.X, amount1, amount2),
+                MathHelper.Barycentric(value1.Y, value2.Y, value3.Y, amount1, amount2),
+                MathHelper.Barycentric(value1.Z, value2.Z, value3.Z, amount1, amount2));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains the cartesian coordinates of a vector specified in barycentric coordinates and relative to 3d-triangle.
+        /// </summary>
+        /// <param name="value1">The first vector of 3d-triangle.</param>
+        /// <param name="value2">The second vector of 3d-triangle.</param>
+        /// <param name="value3">The third vector of 3d-triangle.</param>
+        /// <param name="amount1">Barycentric scalar <c>b2</c> which represents a weighting factor towards second vector of 3d-triangle.</param>
+        /// <param name="amount2">Barycentric scalar <c>b3</c> which represents a weighting factor towards third vector of 3d-triangle.</param>
+        /// <param name="result">The cartesian translation of barycentric coordinates as an output parameter.</param>
+        public static void Barycentric(ref Vector3 value1, ref Vector3 value2, ref Vector3 value3, float amount1, float amount2, out Vector3 result)
+        {
+            result.X = MathHelper.Barycentric(value1.X, value2.X, value3.X, amount1, amount2);
+            result.Y = MathHelper.Barycentric(value1.Y, value2.Y, value3.Y, amount1, amount2);
+            result.Z = MathHelper.Barycentric(value1.Z, value2.Z, value3.Z, amount1, amount2);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains CatmullRom interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">The first vector in interpolation.</param>
+        /// <param name="value2">The second vector in interpolation.</param>
+        /// <param name="value3">The third vector in interpolation.</param>
+        /// <param name="value4">The fourth vector in interpolation.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <returns>The result of CatmullRom interpolation.</returns>
+        public static Vector3 CatmullRom(Vector3 value1, Vector3 value2, Vector3 value3, Vector3 value4, float amount)
+        {
+            return new Vector3(
+                MathHelper.CatmullRom(value1.X, value2.X, value3.X, value4.X, amount),
+                MathHelper.CatmullRom(value1.Y, value2.Y, value3.Y, value4.Y, amount),
+                MathHelper.CatmullRom(value1.Z, value2.Z, value3.Z, value4.Z, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains CatmullRom interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">The first vector in interpolation.</param>
+        /// <param name="value2">The second vector in interpolation.</param>
+        /// <param name="value3">The third vector in interpolation.</param>
+        /// <param name="value4">The fourth vector in interpolation.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <param name="result">The result of CatmullRom interpolation as an output parameter.</param>
+        public static void CatmullRom(ref Vector3 value1, ref Vector3 value2, ref Vector3 value3, ref Vector3 value4, float amount, out Vector3 result)
+        {
+            result.X = MathHelper.CatmullRom(value1.X, value2.X, value3.X, value4.X, amount);
+            result.Y = MathHelper.CatmullRom(value1.Y, value2.Y, value3.Y, value4.Y, amount);
+            result.Z = MathHelper.CatmullRom(value1.Z, value2.Z, value3.Z, value4.Z, amount);
+        }
+
+        /// <summary>
+        /// Round the members of this <see cref="Vector3"/> towards positive infinity.
+        /// </summary>
+        public void Ceiling()
+        {
+            X = (float)Math.Ceiling(X);
+            Y = (float)Math.Ceiling(Y);
+            Z = (float)Math.Ceiling(Z);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains members from another vector rounded towards positive infinity.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <returns>The rounded <see cref="Vector3"/>.</returns>
+        public static Vector3 Ceiling(Vector3 value)
+        {
+            value.X = (float)Math.Ceiling(value.X);
+            value.Y = (float)Math.Ceiling(value.Y);
+            value.Z = (float)Math.Ceiling(value.Z);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains members from another vector rounded towards positive infinity.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <param name="result">The rounded <see cref="Vector3"/>.</param>
+        public static void Ceiling(ref Vector3 value, out Vector3 result)
+        {
+            result.X = (float)Math.Ceiling(value.X);
+            result.Y = (float)Math.Ceiling(value.Y);
+            result.Z = (float)Math.Ceiling(value.Z);
+        }
+
+        /// <summary>
+        /// Clamps the specified value within a range.
+        /// </summary>
+        /// <param name="value1">The value to clamp.</param>
+        /// <param name="min">The min value.</param>
+        /// <param name="max">The max value.</param>
+        /// <returns>The clamped value.</returns>
+        public static Vector3 Clamp(Vector3 value1, Vector3 min, Vector3 max)
+        {
+            return new Vector3(
+                MathHelper.Clamp(value1.X, min.X, max.X),
+                MathHelper.Clamp(value1.Y, min.Y, max.Y),
+                MathHelper.Clamp(value1.Z, min.Z, max.Z));
+        }
+
+        /// <summary>
+        /// Clamps the specified value within a range.
+        /// </summary>
+        /// <param name="value1">The value to clamp.</param>
+        /// <param name="min">The min value.</param>
+        /// <param name="max">The max value.</param>
+        /// <param name="result">The clamped value as an output parameter.</param>
+        public static void Clamp(ref Vector3 value1, ref Vector3 min, ref Vector3 max, out Vector3 result)
+        {
+            result.X = MathHelper.Clamp(value1.X, min.X, max.X);
+            result.Y = MathHelper.Clamp(value1.Y, min.Y, max.Y);
+            result.Z = MathHelper.Clamp(value1.Z, min.Z, max.Z);
+        }
+
+        /// <summary>
+        /// Computes the cross product of two vectors.
+        /// </summary>
+        /// <param name="vector1">The first vector.</param>
+        /// <param name="vector2">The second vector.</param>
+        /// <returns>The cross product of two vectors.</returns>
+        public static Vector3 Cross(Vector3 vector1, Vector3 vector2)
+        {
+            Cross(ref vector1, ref vector2, out vector1);
+            return vector1;
+        }
+
+        /// <summary>
+        /// Computes the cross product of two vectors.
+        /// </summary>
+        /// <param name="vector1">The first vector.</param>
+        /// <param name="vector2">The second vector.</param>
+        /// <param name="result">The cross product of two vectors as an output parameter.</param>
+        public static void Cross(ref Vector3 vector1, ref Vector3 vector2, out Vector3 result)
+        {
+            var x = vector1.Y * vector2.Z - vector2.Y * vector1.Z;
+            var y = -(vector1.X * vector2.Z - vector2.X * vector1.Z);
+            var z = vector1.X * vector2.Y - vector2.X * vector1.Y;
+            result.X = x;
+            result.Y = y;
+            result.Z = z;
+        }
+
+        /// <summary>
+        /// Returns the distance between two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The distance between two vectors.</returns>
+        public static float Distance(Vector3 value1, Vector3 value2)
+        {
+            float result;
+            DistanceSquared(ref value1, ref value2, out result);
+            return (float)Math.Sqrt(result);
+        }
+
+        /// <summary>
+        /// Returns the distance between two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The distance between two vectors as an output parameter.</param>
+        public static void Distance(ref Vector3 value1, ref Vector3 value2, out float result)
+        {
+            DistanceSquared(ref value1, ref value2, out result);
+            result = (float)Math.Sqrt(result);
+        }
+
+        /// <summary>
+        /// Returns the squared distance between two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The squared distance between two vectors.</returns>
+        public static float DistanceSquared(Vector3 value1, Vector3 value2)
+        {
+            return  (value1.X - value2.X) * (value1.X - value2.X) +
+                    (value1.Y - value2.Y) * (value1.Y - value2.Y) +
+                    (value1.Z - value2.Z) * (value1.Z - value2.Z);
+        }
+
+        /// <summary>
+        /// Returns the squared distance between two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The squared distance between two vectors as an output parameter.</param>
+        public static void DistanceSquared(ref Vector3 value1, ref Vector3 value2, out float result)
+        {
+            result = (value1.X - value2.X) * (value1.X - value2.X) +
+                     (value1.Y - value2.Y) * (value1.Y - value2.Y) +
+                     (value1.Z - value2.Z) * (value1.Z - value2.Z);
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector3"/> by the components of another <see cref="Vector3"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/>.</param>
+        /// <param name="value2">Divisor <see cref="Vector3"/>.</param>
+        /// <returns>The result of dividing the vectors.</returns>
+        public static Vector3 Divide(Vector3 value1, Vector3 value2)
+        {
+            value1.X /= value2.X;
+            value1.Y /= value2.Y;
+            value1.Z /= value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector3"/> by a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/>.</param>
+        /// <param name="divider">Divisor scalar.</param>
+        /// <returns>The result of dividing a vector by a scalar.</returns>
+        public static Vector3 Divide(Vector3 value1, float divider)
+        {
+            float factor = 1 / divider;
+            value1.X *= factor;
+            value1.Y *= factor;
+            value1.Z *= factor;
+            return value1;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector3"/> by a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/>.</param>
+        /// <param name="divider">Divisor scalar.</param>
+        /// <param name="result">The result of dividing a vector by a scalar as an output parameter.</param>
+        public static void Divide(ref Vector3 value1, float divider, out Vector3 result)
+        {
+            float factor = 1 / divider;
+            result.X = value1.X * factor;
+            result.Y = value1.Y * factor;
+            result.Z = value1.Z * factor;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector3"/> by the components of another <see cref="Vector3"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/>.</param>
+        /// <param name="value2">Divisor <see cref="Vector3"/>.</param>
+        /// <param name="result">The result of dividing the vectors as an output parameter.</param>
+        public static void Divide(ref Vector3 value1, ref Vector3 value2, out Vector3 result)
+        {
+            result.X = value1.X / value2.X;
+            result.Y = value1.Y / value2.Y;
+            result.Z = value1.Z / value2.Z;
+        }
+
+        /// <summary>
+        /// Returns a dot product of two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The dot product of two vectors.</returns>
+        public static float Dot(Vector3 value1, Vector3 value2)
+        {
+            return value1.X * value2.X + value1.Y * value2.Y + value1.Z * value2.Z;
+        }
+
+        /// <summary>
+        /// Returns a dot product of two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The dot product of two vectors as an output parameter.</param>
+        public static void Dot(ref Vector3 value1, ref Vector3 value2, out float result)
+        {
+            result = value1.X * value2.X + value1.Y * value2.Y + value1.Z * value2.Z;
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Object"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="Object"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            if (!(obj is Vector3))
+                return false;
+
+            var other = (Vector3)obj;
+            return  X == other.X &&
+                    Y == other.Y &&
+                    Z == other.Z;
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Vector3"/>.
+        /// </summary>
+        /// <param name="other">The <see cref="Vector3"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public bool Equals(Vector3 other)
+        {
+            return  X == other.X && 
+                    Y == other.Y &&
+                    Z == other.Z;
+        }
+
+        /// <summary>
+        /// Round the members of this <see cref="Vector3"/> towards negative infinity.
+        /// </summary>
+        public void Floor()
+        {
+            X = (float)Math.Floor(X);
+            Y = (float)Math.Floor(Y);
+            Z = (float)Math.Floor(Z);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains members from another vector rounded towards negative infinity.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <returns>The rounded <see cref="Vector3"/>.</returns>
+        public static Vector3 Floor(Vector3 value)
+        {
+            value.X = (float)Math.Floor(value.X);
+            value.Y = (float)Math.Floor(value.Y);
+            value.Z = (float)Math.Floor(value.Z);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains members from another vector rounded towards negative infinity.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <param name="result">The rounded <see cref="Vector3"/>.</param>
+        public static void Floor(ref Vector3 value, out Vector3 result)
+        {
+            result.X = (float)Math.Floor(value.X);
+            result.Y = (float)Math.Floor(value.Y);
+            result.Z = (float)Math.Floor(value.Z);
+        }
+
+        /// <summary>
+        /// Gets the hash code of this <see cref="Vector3"/>.
+        /// </summary>
+        /// <returns>Hash code of this <see cref="Vector3"/>.</returns>
+        public override int GetHashCode() {
+            unchecked
+            {
+                var hashCode = X.GetHashCode();
+                hashCode = (hashCode * 397) ^ Y.GetHashCode();
+                hashCode = (hashCode * 397) ^ Z.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains hermite spline interpolation.
+        /// </summary>
+        /// <param name="value1">The first position vector.</param>
+        /// <param name="tangent1">The first tangent vector.</param>
+        /// <param name="value2">The second position vector.</param>
+        /// <param name="tangent2">The second tangent vector.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <returns>The hermite spline interpolation vector.</returns>
+        public static Vector3 Hermite(Vector3 value1, Vector3 tangent1, Vector3 value2, Vector3 tangent2, float amount)
+        {
+            return new Vector3(MathHelper.Hermite(value1.X, tangent1.X, value2.X, tangent2.X, amount),
+                               MathHelper.Hermite(value1.Y, tangent1.Y, value2.Y, tangent2.Y, amount),
+                               MathHelper.Hermite(value1.Z, tangent1.Z, value2.Z, tangent2.Z, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains hermite spline interpolation.
+        /// </summary>
+        /// <param name="value1">The first position vector.</param>
+        /// <param name="tangent1">The first tangent vector.</param>
+        /// <param name="value2">The second position vector.</param>
+        /// <param name="tangent2">The second tangent vector.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <param name="result">The hermite spline interpolation vector as an output parameter.</param>
+        public static void Hermite(ref Vector3 value1, ref Vector3 tangent1, ref Vector3 value2, ref Vector3 tangent2, float amount, out Vector3 result)
+        {
+            result.X = MathHelper.Hermite(value1.X, tangent1.X, value2.X, tangent2.X, amount);
+            result.Y = MathHelper.Hermite(value1.Y, tangent1.Y, value2.Y, tangent2.Y, amount);
+            result.Z = MathHelper.Hermite(value1.Z, tangent1.Z, value2.Z, tangent2.Z, amount);
+        }
+
+        /// <summary>
+        /// Returns the length of this <see cref="Vector3"/>.
+        /// </summary>
+        /// <returns>The length of this <see cref="Vector3"/>.</returns>
+        public float Length()
+        {
+            return (float)Math.Sqrt((X * X) + (Y * Y) + (Z * Z));
+        }
+
+        /// <summary>
+        /// Returns the squared length of this <see cref="Vector3"/>.
+        /// </summary>
+        /// <returns>The squared length of this <see cref="Vector3"/>.</returns>
+        public float LengthSquared()
+        {
+            return (X * X) + (Y * Y) + (Z * Z);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains linear interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <returns>The result of linear interpolation of the specified vectors.</returns>
+        public static Vector3 Lerp(Vector3 value1, Vector3 value2, float amount)
+        {
+            return new Vector3(
+                MathHelper.Lerp(value1.X, value2.X, amount),
+                MathHelper.Lerp(value1.Y, value2.Y, amount),
+                MathHelper.Lerp(value1.Z, value2.Z, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains linear interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <param name="result">The result of linear interpolation of the specified vectors as an output parameter.</param>
+        public static void Lerp(ref Vector3 value1, ref Vector3 value2, float amount, out Vector3 result)
+        {
+            result.X = MathHelper.Lerp(value1.X, value2.X, amount);
+            result.Y = MathHelper.Lerp(value1.Y, value2.Y, amount);
+            result.Z = MathHelper.Lerp(value1.Z, value2.Z, amount);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains linear interpolation of the specified vectors.
+        /// Uses <see cref="MathHelper.LerpPrecise"/> on MathHelper for the interpolation.
+        /// Less efficient but more precise compared to <see cref="Vector3.Lerp(Vector3, Vector3, float)"/>.
+        /// See remarks section of <see cref="MathHelper.LerpPrecise"/> on MathHelper for more info.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <returns>The result of linear interpolation of the specified vectors.</returns>
+        public static Vector3 LerpPrecise(Vector3 value1, Vector3 value2, float amount)
+        {
+            return new Vector3(
+                MathHelper.LerpPrecise(value1.X, value2.X, amount),
+                MathHelper.LerpPrecise(value1.Y, value2.Y, amount),
+                MathHelper.LerpPrecise(value1.Z, value2.Z, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains linear interpolation of the specified vectors.
+        /// Uses <see cref="MathHelper.LerpPrecise"/> on MathHelper for the interpolation.
+        /// Less efficient but more precise compared to <see cref="Vector3.Lerp(ref Vector3, ref Vector3, float, out Vector3)"/>.
+        /// See remarks section of <see cref="MathHelper.LerpPrecise"/> on MathHelper for more info.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <param name="result">The result of linear interpolation of the specified vectors as an output parameter.</param>
+        public static void LerpPrecise(ref Vector3 value1, ref Vector3 value2, float amount, out Vector3 result)
+        {
+            result.X = MathHelper.LerpPrecise(value1.X, value2.X, amount);
+            result.Y = MathHelper.LerpPrecise(value1.Y, value2.Y, amount);
+            result.Z = MathHelper.LerpPrecise(value1.Z, value2.Z, amount);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a maximal values from the two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The <see cref="Vector3"/> with maximal values from the two vectors.</returns>
+        public static Vector3 Max(Vector3 value1, Vector3 value2)
+        {
+            return new Vector3(
+                MathHelper.Max(value1.X, value2.X),
+                MathHelper.Max(value1.Y, value2.Y),
+                MathHelper.Max(value1.Z, value2.Z));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a maximal values from the two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The <see cref="Vector3"/> with maximal values from the two vectors as an output parameter.</param>
+        public static void Max(ref Vector3 value1, ref Vector3 value2, out Vector3 result)
+        {
+            result.X = MathHelper.Max(value1.X, value2.X);
+            result.Y = MathHelper.Max(value1.Y, value2.Y);
+            result.Z = MathHelper.Max(value1.Z, value2.Z);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a minimal values from the two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The <see cref="Vector3"/> with minimal values from the two vectors.</returns>
+        public static Vector3 Min(Vector3 value1, Vector3 value2)
+        {
+            return new Vector3(
+                MathHelper.Min(value1.X, value2.X),
+                MathHelper.Min(value1.Y, value2.Y),
+                MathHelper.Min(value1.Z, value2.Z));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a minimal values from the two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The <see cref="Vector3"/> with minimal values from the two vectors as an output parameter.</param>
+        public static void Min(ref Vector3 value1, ref Vector3 value2, out Vector3 result)
+        {
+            result.X = MathHelper.Min(value1.X, value2.X);
+            result.Y = MathHelper.Min(value1.Y, value2.Y);
+            result.Z = MathHelper.Min(value1.Z, value2.Z);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a multiplication of two vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/>.</param>
+        /// <param name="value2">Source <see cref="Vector3"/>.</param>
+        /// <returns>The result of the vector multiplication.</returns>
+        public static Vector3 Multiply(Vector3 value1, Vector3 value2)
+        {
+            value1.X *= value2.X;
+            value1.Y *= value2.Y;
+            value1.Z *= value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a multiplication of <see cref="Vector3"/> and a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/>.</param>
+        /// <param name="scaleFactor">Scalar value.</param>
+        /// <returns>The result of the vector multiplication with a scalar.</returns>
+        public static Vector3 Multiply(Vector3 value1, float scaleFactor)
+        {
+            value1.X *= scaleFactor;
+            value1.Y *= scaleFactor;
+            value1.Z *= scaleFactor;
+            return value1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a multiplication of <see cref="Vector3"/> and a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/>.</param>
+        /// <param name="scaleFactor">Scalar value.</param>
+        /// <param name="result">The result of the multiplication with a scalar as an output parameter.</param>
+        public static void Multiply(ref Vector3 value1, float scaleFactor, out Vector3 result)
+        {
+            result.X = value1.X * scaleFactor;
+            result.Y = value1.Y * scaleFactor;
+            result.Z = value1.Z * scaleFactor;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a multiplication of two vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/>.</param>
+        /// <param name="value2">Source <see cref="Vector3"/>.</param>
+        /// <param name="result">The result of the vector multiplication as an output parameter.</param>
+        public static void Multiply(ref Vector3 value1, ref Vector3 value2, out Vector3 result)
+        {
+            result.X = value1.X * value2.X;
+            result.Y = value1.Y * value2.Y;
+            result.Z = value1.Z * value2.Z;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains the specified vector inversion.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <returns>The result of the vector inversion.</returns>
+        public static Vector3 Negate(Vector3 value)
+        {
+            value = new Vector3(-value.X, -value.Y, -value.Z);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains the specified vector inversion.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <param name="result">The result of the vector inversion as an output parameter.</param>
+        public static void Negate(ref Vector3 value, out Vector3 result)
+        {
+            result.X = -value.X;
+            result.Y = -value.Y;
+            result.Z = -value.Z;
+        }
+
+        /// <summary>
+        /// Turns this <see cref="Vector3"/> to a unit vector with the same direction.
+        /// </summary>
+        public void Normalize()
+        {
+            float factor = (float)Math.Sqrt((X * X) + (Y * Y) + (Z * Z));
+            factor = 1f / factor;
+            X *= factor;
+            Y *= factor;
+            Z *= factor;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a normalized values from another vector.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <returns>Unit vector.</returns>
+        public static Vector3 Normalize(Vector3 value)
+        {
+            float factor = (float)Math.Sqrt((value.X * value.X) + (value.Y * value.Y) + (value.Z * value.Z));
+            factor = 1f / factor;
+            return new Vector3(value.X * factor, value.Y * factor, value.Z * factor);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a normalized values from another vector.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <param name="result">Unit vector as an output parameter.</param>
+        public static void Normalize(ref Vector3 value, out Vector3 result)
+        {
+            float factor = (float)Math.Sqrt((value.X * value.X) + (value.Y * value.Y) + (value.Z * value.Z));
+            factor = 1f / factor;
+            result.X = value.X * factor;
+            result.Y = value.Y * factor;
+            result.Z = value.Z * factor;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains reflect vector of the given vector and normal.
+        /// </summary>
+        /// <param name="vector">Source <see cref="Vector3"/>.</param>
+        /// <param name="normal">Reflection normal.</param>
+        /// <returns>Reflected vector.</returns>
+        public static Vector3 Reflect(Vector3 vector, Vector3 normal)
+        {
+            // I is the original array
+            // N is the normal of the incident plane
+            // R = I - (2 * N * ( DotProduct[ I,N] ))
+            Vector3 reflectedVector;
+            // inline the dotProduct here instead of calling method
+            float dotProduct = ((vector.X * normal.X) + (vector.Y * normal.Y)) + (vector.Z * normal.Z);
+            reflectedVector.X = vector.X - (2.0f * normal.X) * dotProduct;
+            reflectedVector.Y = vector.Y - (2.0f * normal.Y) * dotProduct;
+            reflectedVector.Z = vector.Z - (2.0f * normal.Z) * dotProduct;
+
+            return reflectedVector;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains reflect vector of the given vector and normal.
+        /// </summary>
+        /// <param name="vector">Source <see cref="Vector3"/>.</param>
+        /// <param name="normal">Reflection normal.</param>
+        /// <param name="result">Reflected vector as an output parameter.</param>
+        public static void Reflect(ref Vector3 vector, ref Vector3 normal, out Vector3 result)
+        {
+            // I is the original array
+            // N is the normal of the incident plane
+            // R = I - (2 * N * ( DotProduct[ I,N] ))
+
+            // inline the dotProduct here instead of calling method
+            float dotProduct = ((vector.X * normal.X) + (vector.Y * normal.Y)) + (vector.Z * normal.Z);
+            result.X = vector.X - (2.0f * normal.X) * dotProduct;
+            result.Y = vector.Y - (2.0f * normal.Y) * dotProduct;
+            result.Z = vector.Z - (2.0f * normal.Z) * dotProduct;
+        }
+
+        /// <summary>
+        /// Round the members of this <see cref="Vector3"/> towards the nearest integer value.
+        /// </summary>
+        public void Round()
+        {
+            X = (float)Math.Round(X);
+            Y = (float)Math.Round(Y);
+            Z = (float)Math.Round(Z);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains members from another vector rounded to the nearest integer value.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <returns>The rounded <see cref="Vector3"/>.</returns>
+        public static Vector3 Round(Vector3 value)
+        {
+            value.X = (float)Math.Round(value.X);
+            value.Y = (float)Math.Round(value.Y);
+            value.Z = (float)Math.Round(value.Z);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains members from another vector rounded to the nearest integer value.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <param name="result">The rounded <see cref="Vector3"/>.</param>
+        public static void Round(ref Vector3 value, out Vector3 result)
+        {
+            result.X = (float)Math.Round(value.X);
+            result.Y = (float)Math.Round(value.Y);
+            result.Z = (float)Math.Round(value.Z);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains cubic interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/>.</param>
+        /// <param name="value2">Source <see cref="Vector3"/>.</param>
+        /// <param name="amount">Weighting value.</param>
+        /// <returns>Cubic interpolation of the specified vectors.</returns>
+        public static Vector3 SmoothStep(Vector3 value1, Vector3 value2, float amount)
+        {
+            return new Vector3(
+                MathHelper.SmoothStep(value1.X, value2.X, amount),
+                MathHelper.SmoothStep(value1.Y, value2.Y, amount),
+                MathHelper.SmoothStep(value1.Z, value2.Z, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains cubic interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/>.</param>
+        /// <param name="value2">Source <see cref="Vector3"/>.</param>
+        /// <param name="amount">Weighting value.</param>
+        /// <param name="result">Cubic interpolation of the specified vectors as an output parameter.</param>
+        public static void SmoothStep(ref Vector3 value1, ref Vector3 value2, float amount, out Vector3 result)
+        {
+            result.X = MathHelper.SmoothStep(value1.X, value2.X, amount);
+            result.Y = MathHelper.SmoothStep(value1.Y, value2.Y, amount);
+            result.Z = MathHelper.SmoothStep(value1.Z, value2.Z, amount);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains subtraction of on <see cref="Vector3"/> from a another.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/>.</param>
+        /// <param name="value2">Source <see cref="Vector3"/>.</param>
+        /// <returns>The result of the vector subtraction.</returns>
+        public static Vector3 Subtract(Vector3 value1, Vector3 value2)
+        {
+            value1.X -= value2.X;
+            value1.Y -= value2.Y;
+            value1.Z -= value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains subtraction of on <see cref="Vector3"/> from a another.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/>.</param>
+        /// <param name="value2">Source <see cref="Vector3"/>.</param>
+        /// <param name="result">The result of the vector subtraction as an output parameter.</param>
+        public static void Subtract(ref Vector3 value1, ref Vector3 value2, out Vector3 result)
+        {
+            result.X = value1.X - value2.X;
+            result.Y = value1.Y - value2.Y;
+            result.Z = value1.Z - value2.Z;
+        }
+
+        /// <summary>
+        /// Returns a <see cref="String"/> representation of this <see cref="Vector3"/> in the format:
+        /// {X:[<see cref="X"/>] Y:[<see cref="Y"/>] Z:[<see cref="Z"/>]}
+        /// </summary>
+        /// <returns>A <see cref="String"/> representation of this <see cref="Vector3"/>.</returns>
+        public override string ToString()
+        {
+            StringBuilder sb = new StringBuilder(32);
+            sb.Append("{X:");
+            sb.Append(this.X);
+            sb.Append(" Y:");
+            sb.Append(this.Y);
+            sb.Append(" Z:");
+            sb.Append(this.Z);
+            sb.Append("}");
+            return sb.ToString();
+        }
+
+        #region Transform
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a transformation of 3d-vector by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="position">Source <see cref="Vector3"/>.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <returns>Transformed <see cref="Vector3"/>.</returns>
+        public static Vector3 Transform(Vector3 position, Matrix matrix)
+        {
+            Transform(ref position, ref matrix, out position);
+            return position;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a transformation of 3d-vector by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="position">Source <see cref="Vector3"/>.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="result">Transformed <see cref="Vector3"/> as an output parameter.</param>
+        public static void Transform(ref Vector3 position, ref Matrix matrix, out Vector3 result)
+        {
+            var x = (position.X * matrix.M11) + (position.Y * matrix.M21) + (position.Z * matrix.M31) + matrix.M41;
+            var y = (position.X * matrix.M12) + (position.Y * matrix.M22) + (position.Z * matrix.M32) + matrix.M42;
+            var z = (position.X * matrix.M13) + (position.Y * matrix.M23) + (position.Z * matrix.M33) + matrix.M43;
+            result.X = x;
+            result.Y = y;
+            result.Z = z;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a transformation of 3d-vector by the specified <see cref="Quaternion"/>, representing the rotation.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <returns>Transformed <see cref="Vector3"/>.</returns>
+        public static Vector3 Transform(Vector3 value, Quaternion rotation)
+        {
+            Vector3 result;
+            Transform(ref value, ref rotation, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a transformation of 3d-vector by the specified <see cref="Quaternion"/>, representing the rotation.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <param name="result">Transformed <see cref="Vector3"/> as an output parameter.</param>
+        public static void Transform(ref Vector3 value, ref Quaternion rotation, out Vector3 result)
+        {
+            float x = 2 * (rotation.Y * value.Z - rotation.Z * value.Y);
+            float y = 2 * (rotation.Z * value.X - rotation.X * value.Z);
+            float z = 2 * (rotation.X * value.Y - rotation.Y * value.X);
+
+            result.X = value.X + x * rotation.W + (rotation.Y * z - rotation.Z * y);
+            result.Y = value.Y + y * rotation.W + (rotation.Z * x - rotation.X * z);
+            result.Z = value.Z + z * rotation.W + (rotation.X * y - rotation.Y * x);
+        }
+
+        /// <summary>
+        /// Apply transformation on vectors within array of <see cref="Vector3"/> by the specified <see cref="Matrix"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="sourceIndex">The starting index of transformation in the source array.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        /// <param name="destinationIndex">The starting index in the destination array, where the first <see cref="Vector3"/> should be written.</param>
+        /// <param name="length">The number of vectors to be transformed.</param>
+        public static void Transform(Vector3[] sourceArray, int sourceIndex, ref Matrix matrix, Vector3[] destinationArray, int destinationIndex, int length)
+        {
+            if (sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if (sourceArray.Length < sourceIndex + length)
+                throw new ArgumentException("Source array length is lesser than sourceIndex + length");
+            if (destinationArray.Length < destinationIndex + length)
+                throw new ArgumentException("Destination array length is lesser than destinationIndex + length");
+
+            // TODO: Are there options on some platforms to implement a vectorized version of this?
+
+            for (var i = 0; i < length; i++)
+            {
+                var position = sourceArray[sourceIndex + i];
+                destinationArray[destinationIndex + i] =
+                    new Vector3(
+                        (position.X * matrix.M11) + (position.Y * matrix.M21) + (position.Z * matrix.M31) + matrix.M41,
+                        (position.X * matrix.M12) + (position.Y * matrix.M22) + (position.Z * matrix.M32) + matrix.M42,
+                        (position.X * matrix.M13) + (position.Y * matrix.M23) + (position.Z * matrix.M33) + matrix.M43);
+            }
+        }
+
+        /// <summary>
+        /// Apply transformation on vectors within array of <see cref="Vector3"/> by the specified <see cref="Quaternion"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="sourceIndex">The starting index of transformation in the source array.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        /// <param name="destinationIndex">The starting index in the destination array, where the first <see cref="Vector3"/> should be written.</param>
+        /// <param name="length">The number of vectors to be transformed.</param>
+        public static void Transform(Vector3[] sourceArray, int sourceIndex, ref Quaternion rotation, Vector3[] destinationArray, int destinationIndex, int length)
+        {
+            if (sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if (sourceArray.Length < sourceIndex + length)
+                throw new ArgumentException("Source array length is lesser than sourceIndex + length");
+            if (destinationArray.Length < destinationIndex + length)
+                throw new ArgumentException("Destination array length is lesser than destinationIndex + length");
+
+            // TODO: Are there options on some platforms to implement a vectorized version of this?
+
+            for (var i = 0; i < length; i++)
+            {
+                var position = sourceArray[sourceIndex + i];
+
+                float x = 2 * (rotation.Y * position.Z - rotation.Z * position.Y);
+                float y = 2 * (rotation.Z * position.X - rotation.X * position.Z);
+                float z = 2 * (rotation.X * position.Y - rotation.Y * position.X);
+
+                destinationArray[destinationIndex + i] =
+                    new Vector3(
+                        position.X + x * rotation.W + (rotation.Y * z - rotation.Z * y),
+                        position.Y + y * rotation.W + (rotation.Z * x - rotation.X * z),
+                        position.Z + z * rotation.W + (rotation.X * y - rotation.Y * x));
+            }
+        }
+
+        /// <summary>
+        /// Apply transformation on all vectors within array of <see cref="Vector3"/> by the specified <see cref="Matrix"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        public static void Transform(Vector3[] sourceArray, ref Matrix matrix, Vector3[] destinationArray)
+        {
+            if (sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if (destinationArray.Length < sourceArray.Length)
+                throw new ArgumentException("Destination array length is lesser than source array length");
+
+            // TODO: Are there options on some platforms to implement a vectorized version of this?
+
+            for (var i = 0; i < sourceArray.Length; i++)
+            {
+                var position = sourceArray[i];                
+                destinationArray[i] =
+                    new Vector3(
+                        (position.X*matrix.M11) + (position.Y*matrix.M21) + (position.Z*matrix.M31) + matrix.M41,
+                        (position.X*matrix.M12) + (position.Y*matrix.M22) + (position.Z*matrix.M32) + matrix.M42,
+                        (position.X*matrix.M13) + (position.Y*matrix.M23) + (position.Z*matrix.M33) + matrix.M43);
+            }
+        }
+
+        /// <summary>
+        /// Apply transformation on all vectors within array of <see cref="Vector3"/> by the specified <see cref="Quaternion"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        public static void Transform(Vector3[] sourceArray, ref Quaternion rotation, Vector3[] destinationArray)
+        {
+            if (sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if (destinationArray.Length < sourceArray.Length)
+                throw new ArgumentException("Destination array length is lesser than source array length");
+
+            // TODO: Are there options on some platforms to implement a vectorized version of this?
+
+            for (var i = 0; i < sourceArray.Length; i++)
+            {
+                var position = sourceArray[i];
+
+                float x = 2 * (rotation.Y * position.Z - rotation.Z * position.Y);
+                float y = 2 * (rotation.Z * position.X - rotation.X * position.Z);
+                float z = 2 * (rotation.X * position.Y - rotation.Y * position.X);
+
+                destinationArray[i] =
+                    new Vector3(
+                        position.X + x * rotation.W + (rotation.Y * z - rotation.Z * y),
+                        position.Y + y * rotation.W + (rotation.Z * x - rotation.X * z),
+                        position.Z + z * rotation.W + (rotation.X * y - rotation.Y * x));
+            }
+        }
+
+        #endregion
+
+        #region TransformNormal
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a transformation of the specified normal by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="normal">Source <see cref="Vector3"/> which represents a normal vector.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <returns>Transformed normal.</returns>
+        public static Vector3 TransformNormal(Vector3 normal, Matrix matrix)
+        {
+            TransformNormal(ref normal, ref matrix, out normal);
+            return normal;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector3"/> that contains a transformation of the specified normal by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="normal">Source <see cref="Vector3"/> which represents a normal vector.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="result">Transformed normal as an output parameter.</param>
+        public static void TransformNormal(ref Vector3 normal, ref Matrix matrix, out Vector3 result)
+        {
+            var x = (normal.X * matrix.M11) + (normal.Y * matrix.M21) + (normal.Z * matrix.M31);
+            var y = (normal.X * matrix.M12) + (normal.Y * matrix.M22) + (normal.Z * matrix.M32);
+            var z = (normal.X * matrix.M13) + (normal.Y * matrix.M23) + (normal.Z * matrix.M33);
+            result.X = x;
+            result.Y = y;
+            result.Z = z;
+        }
+
+        /// <summary>
+        /// Apply transformation on normals within array of <see cref="Vector3"/> by the specified <see cref="Matrix"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="sourceIndex">The starting index of transformation in the source array.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        /// <param name="destinationIndex">The starting index in the destination array, where the first <see cref="Vector3"/> should be written.</param>
+        /// <param name="length">The number of normals to be transformed.</param>
+        public static void TransformNormal(Vector3[] sourceArray,
+         int sourceIndex,
+         ref Matrix matrix,
+         Vector3[] destinationArray,
+         int destinationIndex,
+         int length)
+        {
+            if (sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if(sourceArray.Length < sourceIndex + length)
+                throw new ArgumentException("Source array length is lesser than sourceIndex + length");
+            if (destinationArray.Length < destinationIndex + length)
+                throw new ArgumentException("Destination array length is lesser than destinationIndex + length");
+
+            for (int x = 0; x < length; x++)
+            {
+                var normal = sourceArray[sourceIndex + x];
+
+                destinationArray[destinationIndex + x] =
+                     new Vector3(
+                        (normal.X * matrix.M11) + (normal.Y * matrix.M21) + (normal.Z * matrix.M31),
+                        (normal.X * matrix.M12) + (normal.Y * matrix.M22) + (normal.Z * matrix.M32),
+                        (normal.X * matrix.M13) + (normal.Y * matrix.M23) + (normal.Z * matrix.M33));
+            }
+        }
+
+        /// <summary>
+        /// Apply transformation on all normals within array of <see cref="Vector3"/> by the specified <see cref="Matrix"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        public static void TransformNormal(Vector3[] sourceArray, ref Matrix matrix, Vector3[] destinationArray)
+        {
+            if(sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if (destinationArray.Length < sourceArray.Length)
+                throw new ArgumentException("Destination array length is lesser than source array length");
+
+            for (var i = 0; i < sourceArray.Length; i++)
+            {
+                var normal = sourceArray[i];
+
+                destinationArray[i] =
+                    new Vector3(
+                        (normal.X*matrix.M11) + (normal.Y*matrix.M21) + (normal.Z*matrix.M31),
+                        (normal.X*matrix.M12) + (normal.Y*matrix.M22) + (normal.Z*matrix.M32),
+                        (normal.X*matrix.M13) + (normal.Y*matrix.M23) + (normal.Z*matrix.M33));
+            }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Deconstruction method for <see cref="Vector3"/>.
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <param name="z"></param>
+        public void Deconstruct(out float x, out float y, out float z)
+        {
+            x = X;
+            y = Y;
+            z = Z;
+        }
+
+        #endregion
+
+        #region Operators
+
+        /// <summary>
+        /// Compares whether two <see cref="Vector3"/> instances are equal.
+        /// </summary>
+        /// <param name="value1"><see cref="Vector3"/> instance on the left of the equal sign.</param>
+        /// <param name="value2"><see cref="Vector3"/> instance on the right of the equal sign.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Vector3 value1, Vector3 value2)
+        {
+            return value1.X == value2.X
+                && value1.Y == value2.Y
+                && value1.Z == value2.Z;
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="Vector3"/> instances are not equal.
+        /// </summary>
+        /// <param name="value1"><see cref="Vector3"/> instance on the left of the not equal sign.</param>
+        /// <param name="value2"><see cref="Vector3"/> instance on the right of the not equal sign.</param>
+        /// <returns><c>true</c> if the instances are not equal; <c>false</c> otherwise.</returns>	
+        public static bool operator !=(Vector3 value1, Vector3 value2)
+        {
+            return !(value1 == value2);
+        }
+
+        /// <summary>
+        /// Adds two vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/> on the left of the add sign.</param>
+        /// <param name="value2">Source <see cref="Vector3"/> on the right of the add sign.</param>
+        /// <returns>Sum of the vectors.</returns>
+        public static Vector3 operator +(Vector3 value1, Vector3 value2)
+        {
+            value1.X += value2.X;
+            value1.Y += value2.Y;
+            value1.Z += value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Inverts values in the specified <see cref="Vector3"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/> on the right of the sub sign.</param>
+        /// <returns>Result of the inversion.</returns>
+        public static Vector3 operator -(Vector3 value)
+        {
+            value = new Vector3(-value.X, -value.Y, -value.Z);
+            return value;
+        }
+
+        /// <summary>
+        /// Subtracts a <see cref="Vector3"/> from a <see cref="Vector3"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/> on the left of the sub sign.</param>
+        /// <param name="value2">Source <see cref="Vector3"/> on the right of the sub sign.</param>
+        /// <returns>Result of the vector subtraction.</returns>
+        public static Vector3 operator -(Vector3 value1, Vector3 value2)
+        {
+            value1.X -= value2.X;
+            value1.Y -= value2.Y;
+            value1.Z -= value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Multiplies the components of two vectors by each other.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/> on the left of the mul sign.</param>
+        /// <param name="value2">Source <see cref="Vector3"/> on the right of the mul sign.</param>
+        /// <returns>Result of the vector multiplication.</returns>
+        public static Vector3 operator *(Vector3 value1, Vector3 value2)
+        {
+            value1.X *= value2.X;
+            value1.Y *= value2.Y;
+            value1.Z *= value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Multiplies the components of vector by a scalar.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/> on the left of the mul sign.</param>
+        /// <param name="scaleFactor">Scalar value on the right of the mul sign.</param>
+        /// <returns>Result of the vector multiplication with a scalar.</returns>
+        public static Vector3 operator *(Vector3 value, float scaleFactor)
+        {
+            value.X *= scaleFactor;
+            value.Y *= scaleFactor;
+            value.Z *= scaleFactor;
+            return value;
+        }
+
+        /// <summary>
+        /// Multiplies the components of vector by a scalar.
+        /// </summary>
+        /// <param name="scaleFactor">Scalar value on the left of the mul sign.</param>
+        /// <param name="value">Source <see cref="Vector3"/> on the right of the mul sign.</param>
+        /// <returns>Result of the vector multiplication with a scalar.</returns>
+        public static Vector3 operator *(float scaleFactor, Vector3 value)
+        {
+            value.X *= scaleFactor;
+            value.Y *= scaleFactor;
+            value.Z *= scaleFactor;
+            return value;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector3"/> by the components of another <see cref="Vector3"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/> on the left of the div sign.</param>
+        /// <param name="value2">Divisor <see cref="Vector3"/> on the right of the div sign.</param>
+        /// <returns>The result of dividing the vectors.</returns>
+        public static Vector3 operator /(Vector3 value1, Vector3 value2)
+        {
+            value1.X /= value2.X;
+            value1.Y /= value2.Y;
+            value1.Z /= value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector3"/> by a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector3"/> on the left of the div sign.</param>
+        /// <param name="divider">Divisor scalar on the right of the div sign.</param>
+        /// <returns>The result of dividing a vector by a scalar.</returns>
+        public static Vector3 operator /(Vector3 value1, float divider)
+        {
+            float factor = 1 / divider;
+            value1.X *= factor;
+            value1.Y *= factor;
+            value1.Z *= factor;
+            return value1;
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Vector4.cs b/MonoGame.Framework/Vector4.cs
new file mode 100644
index 00000000000..d1e1942f2c0
--- /dev/null
+++ b/MonoGame.Framework/Vector4.cs
@@ -0,0 +1,1411 @@
+// MIT License - Copyright (C) The Mono.Xna Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Runtime.Serialization;
+using System.Diagnostics;
+
+namespace Microsoft.Xna.Framework
+{
+    /// <summary>
+    /// Describes a 4D-vector.
+    /// </summary>
+#if XNADESIGNPROVIDED
+    [System.ComponentModel.TypeConverter(typeof(Microsoft.Xna.Framework.Design.Vector4TypeConverter))]
+#endif
+    [DataContract]
+    [DebuggerDisplay("{DebugDisplayString,nq}")]
+    public struct Vector4 : IEquatable<Vector4>
+    {
+        #region Private Fields
+
+        private static readonly Vector4 zero = new Vector4();
+        private static readonly Vector4 one = new Vector4(1f, 1f, 1f, 1f);
+        private static readonly Vector4 unitX = new Vector4(1f, 0f, 0f, 0f);
+        private static readonly Vector4 unitY = new Vector4(0f, 1f, 0f, 0f);
+        private static readonly Vector4 unitZ = new Vector4(0f, 0f, 1f, 0f);
+        private static readonly Vector4 unitW = new Vector4(0f, 0f, 0f, 1f);
+
+        #endregion
+
+        #region Public Fields
+
+        /// <summary>
+        /// The x coordinate of this <see cref="Vector4"/>.
+        /// </summary>
+        [DataMember]
+        public float X;
+
+        /// <summary>
+        /// The y coordinate of this <see cref="Vector4"/>.
+        /// </summary>
+        [DataMember]
+        public float Y;
+
+        /// <summary>
+        /// The z coordinate of this <see cref="Vector4"/>.
+        /// </summary>
+        [DataMember]
+        public float Z;
+
+        /// <summary>
+        /// The w coordinate of this <see cref="Vector4"/>.
+        /// </summary>
+        [DataMember]
+        public float W;
+
+        #endregion
+
+        #region Public Properties
+
+        /// <summary>
+        /// Returns a <see cref="Vector4"/> with components 0, 0, 0, 0.
+        /// </summary>
+        public static Vector4 Zero
+        {
+            get { return zero; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector4"/> with components 1, 1, 1, 1.
+        /// </summary>
+        public static Vector4 One
+        {
+            get { return one; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector4"/> with components 1, 0, 0, 0.
+        /// </summary>
+        public static Vector4 UnitX
+        {
+            get { return unitX; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector4"/> with components 0, 1, 0, 0.
+        /// </summary>
+        public static Vector4 UnitY
+        {
+            get { return unitY; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector4"/> with components 0, 0, 1, 0.
+        /// </summary>
+        public static Vector4 UnitZ
+        {
+            get { return unitZ; }
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Vector4"/> with components 0, 0, 0, 1.
+        /// </summary>
+        public static Vector4 UnitW
+        {
+            get { return unitW; }
+        }
+
+        #endregion
+
+        #region Internal Properties
+
+        internal string DebugDisplayString
+        {
+            get
+            {
+                return string.Concat(
+                    this.X.ToString(), "  ",
+                    this.Y.ToString(), "  ",
+                    this.Z.ToString(), "  ",
+                    this.W.ToString()
+                );
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Constructs a 3d vector with X, Y, Z and W from four values.
+        /// </summary>
+        /// <param name="x">The x coordinate in 4d-space.</param>
+        /// <param name="y">The y coordinate in 4d-space.</param>
+        /// <param name="z">The z coordinate in 4d-space.</param>
+        /// <param name="w">The w coordinate in 4d-space.</param>
+        public Vector4(float x, float y, float z, float w)
+        {
+            this.X = x;
+            this.Y = y;
+            this.Z = z;
+            this.W = w;
+        }
+
+        /// <summary>
+        /// Constructs a 3d vector with X and Z from <see cref="Vector2"/> and Z and W from the scalars.
+        /// </summary>
+        /// <param name="value">The x and y coordinates in 4d-space.</param>
+        /// <param name="z">The z coordinate in 4d-space.</param>
+        /// <param name="w">The w coordinate in 4d-space.</param>
+        public Vector4(Vector2 value, float z, float w)
+        {
+            this.X = value.X;
+            this.Y = value.Y;
+            this.Z = z;
+            this.W = w;
+        }
+
+        /// <summary>
+        /// Constructs a 3d vector with X, Y, Z from <see cref="Vector3"/> and W from a scalar.
+        /// </summary>
+        /// <param name="value">The x, y and z coordinates in 4d-space.</param>
+        /// <param name="w">The w coordinate in 4d-space.</param>
+        public Vector4(Vector3 value, float w)
+        {
+            this.X = value.X;
+            this.Y = value.Y;
+            this.Z = value.Z;
+            this.W = w;
+        }
+
+        /// <summary>
+        /// Constructs a 4d vector with X, Y, Z and W set to the same value.
+        /// </summary>
+        /// <param name="value">The x, y, z and w coordinates in 4d-space.</param>
+        public Vector4(float value)
+        {
+            this.X = value;
+            this.Y = value;
+            this.Z = value;
+            this.W = value;
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Performs vector addition on <paramref name="value1"/> and <paramref name="value2"/>.
+        /// </summary>
+        /// <param name="value1">The first vector to add.</param>
+        /// <param name="value2">The second vector to add.</param>
+        /// <returns>The result of the vector addition.</returns>
+        public static Vector4 Add(Vector4 value1, Vector4 value2)
+        {
+            value1.X += value2.X;
+            value1.Y += value2.Y;
+            value1.Z += value2.Z;
+            value1.W += value2.W;
+            return value1;
+        }
+
+        /// <summary>
+        /// Performs vector addition on <paramref name="value1"/> and
+        /// <paramref name="value2"/>, storing the result of the
+        /// addition in <paramref name="result"/>.
+        /// </summary>
+        /// <param name="value1">The first vector to add.</param>
+        /// <param name="value2">The second vector to add.</param>
+        /// <param name="result">The result of the vector addition.</param>
+        public static void Add(ref Vector4 value1, ref Vector4 value2, out Vector4 result)
+        {
+            result.X = value1.X + value2.X;
+            result.Y = value1.Y + value2.Y;
+            result.Z = value1.Z + value2.Z;
+            result.W = value1.W + value2.W;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains the cartesian coordinates of a vector specified in barycentric coordinates and relative to 4d-triangle.
+        /// </summary>
+        /// <param name="value1">The first vector of 4d-triangle.</param>
+        /// <param name="value2">The second vector of 4d-triangle.</param>
+        /// <param name="value3">The third vector of 4d-triangle.</param>
+        /// <param name="amount1">Barycentric scalar <c>b2</c> which represents a weighting factor towards second vector of 4d-triangle.</param>
+        /// <param name="amount2">Barycentric scalar <c>b3</c> which represents a weighting factor towards third vector of 4d-triangle.</param>
+        /// <returns>The cartesian translation of barycentric coordinates.</returns>
+        public static Vector4 Barycentric(Vector4 value1, Vector4 value2, Vector4 value3, float amount1, float amount2)
+        {
+            return new Vector4(
+                MathHelper.Barycentric(value1.X, value2.X, value3.X, amount1, amount2),
+                MathHelper.Barycentric(value1.Y, value2.Y, value3.Y, amount1, amount2),
+                MathHelper.Barycentric(value1.Z, value2.Z, value3.Z, amount1, amount2),
+                MathHelper.Barycentric(value1.W, value2.W, value3.W, amount1, amount2));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains the cartesian coordinates of a vector specified in barycentric coordinates and relative to 4d-triangle.
+        /// </summary>
+        /// <param name="value1">The first vector of 4d-triangle.</param>
+        /// <param name="value2">The second vector of 4d-triangle.</param>
+        /// <param name="value3">The third vector of 4d-triangle.</param>
+        /// <param name="amount1">Barycentric scalar <c>b2</c> which represents a weighting factor towards second vector of 4d-triangle.</param>
+        /// <param name="amount2">Barycentric scalar <c>b3</c> which represents a weighting factor towards third vector of 4d-triangle.</param>
+        /// <param name="result">The cartesian translation of barycentric coordinates as an output parameter.</param>
+        public static void Barycentric(ref Vector4 value1, ref Vector4 value2, ref Vector4 value3, float amount1, float amount2, out Vector4 result)
+        {
+            result.X = MathHelper.Barycentric(value1.X, value2.X, value3.X, amount1, amount2);
+            result.Y = MathHelper.Barycentric(value1.Y, value2.Y, value3.Y, amount1, amount2);
+            result.Z = MathHelper.Barycentric(value1.Z, value2.Z, value3.Z, amount1, amount2);
+            result.W = MathHelper.Barycentric(value1.W, value2.W, value3.W, amount1, amount2);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains CatmullRom interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">The first vector in interpolation.</param>
+        /// <param name="value2">The second vector in interpolation.</param>
+        /// <param name="value3">The third vector in interpolation.</param>
+        /// <param name="value4">The fourth vector in interpolation.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <returns>The result of CatmullRom interpolation.</returns>
+        public static Vector4 CatmullRom(Vector4 value1, Vector4 value2, Vector4 value3, Vector4 value4, float amount)
+        {
+            return new Vector4(
+                MathHelper.CatmullRom(value1.X, value2.X, value3.X, value4.X, amount),
+                MathHelper.CatmullRom(value1.Y, value2.Y, value3.Y, value4.Y, amount),
+                MathHelper.CatmullRom(value1.Z, value2.Z, value3.Z, value4.Z, amount),
+                MathHelper.CatmullRom(value1.W, value2.W, value3.W, value4.W, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains CatmullRom interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">The first vector in interpolation.</param>
+        /// <param name="value2">The second vector in interpolation.</param>
+        /// <param name="value3">The third vector in interpolation.</param>
+        /// <param name="value4">The fourth vector in interpolation.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <param name="result">The result of CatmullRom interpolation as an output parameter.</param>
+        public static void CatmullRom(ref Vector4 value1, ref Vector4 value2, ref Vector4 value3, ref Vector4 value4, float amount, out Vector4 result)
+        {
+            result.X = MathHelper.CatmullRom(value1.X, value2.X, value3.X, value4.X, amount);
+            result.Y = MathHelper.CatmullRom(value1.Y, value2.Y, value3.Y, value4.Y, amount);
+            result.Z = MathHelper.CatmullRom(value1.Z, value2.Z, value3.Z, value4.Z, amount);
+            result.W = MathHelper.CatmullRom(value1.W, value2.W, value3.W, value4.W, amount);
+        }
+
+        /// <summary>
+        /// Round the members of this <see cref="Vector4"/> towards positive infinity.
+        /// </summary>
+        public void Ceiling()
+        {
+            X = (float)Math.Ceiling(X);
+            Y = (float)Math.Ceiling(Y);
+            Z = (float)Math.Ceiling(Z);
+            W = (float)Math.Ceiling(W);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains members from another vector rounded towards positive infinity.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <returns>The rounded <see cref="Vector4"/>.</returns>
+        public static Vector4 Ceiling(Vector4 value)
+        {
+            value.X = (float)Math.Ceiling(value.X);
+            value.Y = (float)Math.Ceiling(value.Y);
+            value.Z = (float)Math.Ceiling(value.Z);
+            value.W = (float)Math.Ceiling(value.W);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains members from another vector rounded towards positive infinity.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <param name="result">The rounded <see cref="Vector4"/>.</param>
+        public static void Ceiling(ref Vector4 value, out Vector4 result)
+        {
+            result.X = (float)Math.Ceiling(value.X);
+            result.Y = (float)Math.Ceiling(value.Y);
+            result.Z = (float)Math.Ceiling(value.Z);
+            result.W = (float)Math.Ceiling(value.W);
+        }
+
+        /// <summary>
+        /// Clamps the specified value within a range.
+        /// </summary>
+        /// <param name="value1">The value to clamp.</param>
+        /// <param name="min">The min value.</param>
+        /// <param name="max">The max value.</param>
+        /// <returns>The clamped value.</returns>
+        public static Vector4 Clamp(Vector4 value1, Vector4 min, Vector4 max)
+        {
+            return new Vector4(
+                MathHelper.Clamp(value1.X, min.X, max.X),
+                MathHelper.Clamp(value1.Y, min.Y, max.Y),
+                MathHelper.Clamp(value1.Z, min.Z, max.Z),
+                MathHelper.Clamp(value1.W, min.W, max.W));
+        }
+
+        /// <summary>
+        /// Clamps the specified value within a range.
+        /// </summary>
+        /// <param name="value1">The value to clamp.</param>
+        /// <param name="min">The min value.</param>
+        /// <param name="max">The max value.</param>
+        /// <param name="result">The clamped value as an output parameter.</param>
+        public static void Clamp(ref Vector4 value1, ref Vector4 min, ref Vector4 max, out Vector4 result)
+        {
+            result.X = MathHelper.Clamp(value1.X, min.X, max.X);
+            result.Y = MathHelper.Clamp(value1.Y, min.Y, max.Y);
+            result.Z = MathHelper.Clamp(value1.Z, min.Z, max.Z);
+            result.W = MathHelper.Clamp(value1.W, min.W, max.W);
+        }
+
+        /// <summary>
+        /// Returns the distance between two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The distance between two vectors.</returns>
+        public static float Distance(Vector4 value1, Vector4 value2)
+        {
+            return (float)Math.Sqrt(DistanceSquared(value1, value2));
+        }
+
+        /// <summary>
+        /// Returns the distance between two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The distance between two vectors as an output parameter.</param>
+        public static void Distance(ref Vector4 value1, ref Vector4 value2, out float result)
+        {
+            result = (float)Math.Sqrt(DistanceSquared(value1, value2));
+        }
+
+        /// <summary>
+        /// Returns the squared distance between two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The squared distance between two vectors.</returns>
+        public static float DistanceSquared(Vector4 value1, Vector4 value2)
+        {
+              return (value1.W - value2.W) * (value1.W - value2.W) +
+                     (value1.X - value2.X) * (value1.X - value2.X) +
+                     (value1.Y - value2.Y) * (value1.Y - value2.Y) +
+                     (value1.Z - value2.Z) * (value1.Z - value2.Z);
+        }
+
+        /// <summary>
+        /// Returns the squared distance between two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The squared distance between two vectors as an output parameter.</param>
+        public static void DistanceSquared(ref Vector4 value1, ref Vector4 value2, out float result)
+        {
+            result = (value1.W - value2.W) * (value1.W - value2.W) +
+                     (value1.X - value2.X) * (value1.X - value2.X) +
+                     (value1.Y - value2.Y) * (value1.Y - value2.Y) +
+                     (value1.Z - value2.Z) * (value1.Z - value2.Z);
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector4"/> by the components of another <see cref="Vector4"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/>.</param>
+        /// <param name="value2">Divisor <see cref="Vector4"/>.</param>
+        /// <returns>The result of dividing the vectors.</returns>
+        public static Vector4 Divide(Vector4 value1, Vector4 value2)
+        {
+            value1.W /= value2.W;
+            value1.X /= value2.X;
+            value1.Y /= value2.Y;
+            value1.Z /= value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector4"/> by a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/>.</param>
+        /// <param name="divider">Divisor scalar.</param>
+        /// <returns>The result of dividing a vector by a scalar.</returns>
+        public static Vector4 Divide(Vector4 value1, float divider)
+        {
+            float factor = 1f / divider;
+            value1.W *= factor;
+            value1.X *= factor;
+            value1.Y *= factor;
+            value1.Z *= factor;
+            return value1;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector4"/> by a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/>.</param>
+        /// <param name="divider">Divisor scalar.</param>
+        /// <param name="result">The result of dividing a vector by a scalar as an output parameter.</param>
+        public static void Divide(ref Vector4 value1, float divider, out Vector4 result)
+        {
+            float factor = 1f / divider;
+            result.W = value1.W * factor;
+            result.X = value1.X * factor;
+            result.Y = value1.Y * factor;
+            result.Z = value1.Z * factor;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector4"/> by the components of another <see cref="Vector4"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/>.</param>
+        /// <param name="value2">Divisor <see cref="Vector4"/>.</param>
+        /// <param name="result">The result of dividing the vectors as an output parameter.</param>
+        public static void Divide(ref Vector4 value1, ref Vector4 value2, out Vector4 result)
+        {
+            result.W = value1.W / value2.W;
+            result.X = value1.X / value2.X;
+            result.Y = value1.Y / value2.Y;
+            result.Z = value1.Z / value2.Z;
+        }
+
+        /// <summary>
+        /// Returns a dot product of two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The dot product of two vectors.</returns>
+        public static float Dot(Vector4 value1, Vector4 value2)
+        {
+            return value1.X * value2.X + value1.Y * value2.Y + value1.Z * value2.Z + value1.W * value2.W;
+        }
+
+        /// <summary>
+        /// Returns a dot product of two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The dot product of two vectors as an output parameter.</param>
+        public static void Dot(ref Vector4 value1, ref Vector4 value2, out float result)
+        {
+            result = value1.X * value2.X + value1.Y * value2.Y + value1.Z * value2.Z + value1.W * value2.W;
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Object"/>.
+        /// </summary>
+        /// <param name="obj">The <see cref="Object"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            return (obj is Vector4) ? this == (Vector4)obj : false;
+        }
+
+        /// <summary>
+        /// Compares whether current instance is equal to specified <see cref="Vector4"/>.
+        /// </summary>
+        /// <param name="other">The <see cref="Vector4"/> to compare.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public bool Equals(Vector4 other)
+        {
+            return this.W == other.W
+                && this.X == other.X
+                && this.Y == other.Y
+                && this.Z == other.Z;
+        }
+
+        /// <summary>
+        /// Round the members of this <see cref="Vector4"/> towards negative infinity.
+        /// </summary>
+        public void Floor()
+        {
+            X = (float)Math.Floor(X);
+            Y = (float)Math.Floor(Y);
+            Z = (float)Math.Floor(Z);
+            W = (float)Math.Floor(W);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains members from another vector rounded towards negative infinity.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <returns>The rounded <see cref="Vector4"/>.</returns>
+        public static Vector4 Floor(Vector4 value)
+        {
+            value.X = (float)Math.Floor(value.X);
+            value.Y = (float)Math.Floor(value.Y);
+            value.Z = (float)Math.Floor(value.Z);
+            value.W = (float)Math.Floor(value.W);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains members from another vector rounded towards negative infinity.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <param name="result">The rounded <see cref="Vector4"/>.</param>
+        public static void Floor(ref Vector4 value, out Vector4 result)
+        {
+            result.X = (float)Math.Floor(value.X);
+            result.Y = (float)Math.Floor(value.Y);
+            result.Z = (float)Math.Floor(value.Z);
+            result.W = (float)Math.Floor(value.W);
+        }
+
+        /// <summary>
+        /// Gets the hash code of this <see cref="Vector4"/>.
+        /// </summary>
+        /// <returns>Hash code of this <see cref="Vector4"/>.</returns>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = W.GetHashCode();
+                hashCode = (hashCode * 397) ^ X.GetHashCode();
+                hashCode = (hashCode * 397) ^ Y.GetHashCode();
+                hashCode = (hashCode * 397) ^ Z.GetHashCode();
+                return hashCode;
+            }
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains hermite spline interpolation.
+        /// </summary>
+        /// <param name="value1">The first position vector.</param>
+        /// <param name="tangent1">The first tangent vector.</param>
+        /// <param name="value2">The second position vector.</param>
+        /// <param name="tangent2">The second tangent vector.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <returns>The hermite spline interpolation vector.</returns>
+        public static Vector4 Hermite(Vector4 value1, Vector4 tangent1, Vector4 value2, Vector4 tangent2, float amount)
+        {
+            return new Vector4(MathHelper.Hermite(value1.X, tangent1.X, value2.X, tangent2.X, amount),
+                               MathHelper.Hermite(value1.Y, tangent1.Y, value2.Y, tangent2.Y, amount),
+                               MathHelper.Hermite(value1.Z, tangent1.Z, value2.Z, tangent2.Z, amount),
+                               MathHelper.Hermite(value1.W, tangent1.W, value2.W, tangent2.W, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains hermite spline interpolation.
+        /// </summary>
+        /// <param name="value1">The first position vector.</param>
+        /// <param name="tangent1">The first tangent vector.</param>
+        /// <param name="value2">The second position vector.</param>
+        /// <param name="tangent2">The second tangent vector.</param>
+        /// <param name="amount">Weighting factor.</param>
+        /// <param name="result">The hermite spline interpolation vector as an output parameter.</param>
+        public static void Hermite(ref Vector4 value1, ref Vector4 tangent1, ref Vector4 value2, ref Vector4 tangent2, float amount, out Vector4 result)
+        {
+            result.W = MathHelper.Hermite(value1.W, tangent1.W, value2.W, tangent2.W, amount);
+            result.X = MathHelper.Hermite(value1.X, tangent1.X, value2.X, tangent2.X, amount);
+            result.Y = MathHelper.Hermite(value1.Y, tangent1.Y, value2.Y, tangent2.Y, amount);
+            result.Z = MathHelper.Hermite(value1.Z, tangent1.Z, value2.Z, tangent2.Z, amount);
+        }
+
+        /// <summary>
+        /// Returns the length of this <see cref="Vector4"/>.
+        /// </summary>
+        /// <returns>The length of this <see cref="Vector4"/>.</returns>
+        public float Length()
+        {
+            return (float)Math.Sqrt((X * X) + (Y * Y) + (Z * Z) + (W * W));
+        }
+
+        /// <summary>
+        /// Returns the squared length of this <see cref="Vector4"/>.
+        /// </summary>
+        /// <returns>The squared length of this <see cref="Vector4"/>.</returns>
+        public float LengthSquared()
+        {
+            return (X * X) + (Y * Y) + (Z * Z) + (W * W);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains linear interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <returns>The result of linear interpolation of the specified vectors.</returns>
+        public static Vector4 Lerp(Vector4 value1, Vector4 value2, float amount)
+        {
+            return new Vector4(
+                MathHelper.Lerp(value1.X, value2.X, amount),
+                MathHelper.Lerp(value1.Y, value2.Y, amount),
+                MathHelper.Lerp(value1.Z, value2.Z, amount),
+                MathHelper.Lerp(value1.W, value2.W, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains linear interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <param name="result">The result of linear interpolation of the specified vectors as an output parameter.</param>
+        public static void Lerp(ref Vector4 value1, ref Vector4 value2, float amount, out Vector4 result)
+        {
+            result.X = MathHelper.Lerp(value1.X, value2.X, amount);
+            result.Y = MathHelper.Lerp(value1.Y, value2.Y, amount);
+            result.Z = MathHelper.Lerp(value1.Z, value2.Z, amount);
+            result.W = MathHelper.Lerp(value1.W, value2.W, amount);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains linear interpolation of the specified vectors.
+        /// Uses <see cref="MathHelper.LerpPrecise"/> on MathHelper for the interpolation.
+        /// Less efficient but more precise compared to <see cref="Vector4.Lerp(Vector4, Vector4, float)"/>.
+        /// See remarks section of <see cref="MathHelper.LerpPrecise"/> on MathHelper for more info.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <returns>The result of linear interpolation of the specified vectors.</returns>
+        public static Vector4 LerpPrecise(Vector4 value1, Vector4 value2, float amount)
+        {
+            return new Vector4(
+                MathHelper.LerpPrecise(value1.X, value2.X, amount),
+                MathHelper.LerpPrecise(value1.Y, value2.Y, amount),
+                MathHelper.LerpPrecise(value1.Z, value2.Z, amount),
+                MathHelper.LerpPrecise(value1.W, value2.W, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains linear interpolation of the specified vectors.
+        /// Uses <see cref="MathHelper.LerpPrecise"/> on MathHelper for the interpolation.
+        /// Less efficient but more precise compared to <see cref="Vector4.Lerp(ref Vector4, ref Vector4, float, out Vector4)"/>.
+        /// See remarks section of <see cref="MathHelper.LerpPrecise"/> on MathHelper for more info.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="amount">Weighting value(between 0.0 and 1.0).</param>
+        /// <param name="result">The result of linear interpolation of the specified vectors as an output parameter.</param>
+        public static void LerpPrecise(ref Vector4 value1, ref Vector4 value2, float amount, out Vector4 result)
+        {
+            result.X = MathHelper.LerpPrecise(value1.X, value2.X, amount);
+            result.Y = MathHelper.LerpPrecise(value1.Y, value2.Y, amount);
+            result.Z = MathHelper.LerpPrecise(value1.Z, value2.Z, amount);
+            result.W = MathHelper.LerpPrecise(value1.W, value2.W, amount);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a maximal values from the two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The <see cref="Vector4"/> with maximal values from the two vectors.</returns>
+        public static Vector4 Max(Vector4 value1, Vector4 value2)
+        {
+            return new Vector4(
+               MathHelper.Max(value1.X, value2.X),
+               MathHelper.Max(value1.Y, value2.Y),
+               MathHelper.Max(value1.Z, value2.Z),
+               MathHelper.Max(value1.W, value2.W));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a maximal values from the two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The <see cref="Vector4"/> with maximal values from the two vectors as an output parameter.</param>
+        public static void Max(ref Vector4 value1, ref Vector4 value2, out Vector4 result)
+        {
+            result.X = MathHelper.Max(value1.X, value2.X);
+            result.Y = MathHelper.Max(value1.Y, value2.Y);
+            result.Z = MathHelper.Max(value1.Z, value2.Z);
+            result.W = MathHelper.Max(value1.W, value2.W);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a minimal values from the two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <returns>The <see cref="Vector4"/> with minimal values from the two vectors.</returns>
+        public static Vector4 Min(Vector4 value1, Vector4 value2)
+        {
+            return new Vector4(
+               MathHelper.Min(value1.X, value2.X),
+               MathHelper.Min(value1.Y, value2.Y),
+               MathHelper.Min(value1.Z, value2.Z),
+               MathHelper.Min(value1.W, value2.W));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a minimal values from the two vectors.
+        /// </summary>
+        /// <param name="value1">The first vector.</param>
+        /// <param name="value2">The second vector.</param>
+        /// <param name="result">The <see cref="Vector4"/> with minimal values from the two vectors as an output parameter.</param>
+        public static void Min(ref Vector4 value1, ref Vector4 value2, out Vector4 result)
+        {
+            result.X = MathHelper.Min(value1.X, value2.X);
+            result.Y = MathHelper.Min(value1.Y, value2.Y);
+            result.Z = MathHelper.Min(value1.Z, value2.Z);
+            result.W = MathHelper.Min(value1.W, value2.W);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a multiplication of two vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/>.</param>
+        /// <param name="value2">Source <see cref="Vector4"/>.</param>
+        /// <returns>The result of the vector multiplication.</returns>
+        public static Vector4 Multiply(Vector4 value1, Vector4 value2)
+        {
+            value1.W *= value2.W;
+            value1.X *= value2.X;
+            value1.Y *= value2.Y;
+            value1.Z *= value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a multiplication of <see cref="Vector4"/> and a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/>.</param>
+        /// <param name="scaleFactor">Scalar value.</param>
+        /// <returns>The result of the vector multiplication with a scalar.</returns>
+        public static Vector4 Multiply(Vector4 value1, float scaleFactor)
+        {
+            value1.W *= scaleFactor;
+            value1.X *= scaleFactor;
+            value1.Y *= scaleFactor;
+            value1.Z *= scaleFactor;
+            return value1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a multiplication of <see cref="Vector4"/> and a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/>.</param>
+        /// <param name="scaleFactor">Scalar value.</param>
+        /// <param name="result">The result of the multiplication with a scalar as an output parameter.</param>
+        public static void Multiply(ref Vector4 value1, float scaleFactor, out Vector4 result)
+        {
+            result.W = value1.W * scaleFactor;
+            result.X = value1.X * scaleFactor;
+            result.Y = value1.Y * scaleFactor;
+            result.Z = value1.Z * scaleFactor;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a multiplication of two vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/>.</param>
+        /// <param name="value2">Source <see cref="Vector4"/>.</param>
+        /// <param name="result">The result of the vector multiplication as an output parameter.</param>
+        public static void Multiply(ref Vector4 value1, ref Vector4 value2, out Vector4 result)
+        {
+            result.W = value1.W * value2.W;
+            result.X = value1.X * value2.X;
+            result.Y = value1.Y * value2.Y;
+            result.Z = value1.Z * value2.Z;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains the specified vector inversion.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <returns>The result of the vector inversion.</returns>
+        public static Vector4 Negate(Vector4 value)
+        {
+            value = new Vector4(-value.X, -value.Y, -value.Z, -value.W);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains the specified vector inversion.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <param name="result">The result of the vector inversion as an output parameter.</param>
+        public static void Negate(ref Vector4 value, out Vector4 result)
+        {
+            result.X = -value.X;
+            result.Y = -value.Y;
+            result.Z = -value.Z;
+            result.W = -value.W;
+        }
+
+        /// <summary>
+        /// Turns this <see cref="Vector4"/> to a unit vector with the same direction.
+        /// </summary>
+        public void Normalize()
+        {
+            float factor = (float)Math.Sqrt((X * X) + (Y * Y) + (Z * Z) + (W * W));
+            factor = 1f / factor;
+            X *= factor;
+            Y *= factor;
+            Z *= factor;
+            W *= factor;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a normalized values from another vector.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <returns>Unit vector.</returns>
+        public static Vector4 Normalize(Vector4 value)
+        {
+            float factor = (float)Math.Sqrt((value.X * value.X) + (value.Y * value.Y) + (value.Z * value.Z) + (value.W * value.W));
+            factor = 1f / factor;
+            return new Vector4(value.X*factor,value.Y*factor,value.Z*factor,value.W*factor);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a normalized values from another vector.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <param name="result">Unit vector as an output parameter.</param>
+        public static void Normalize(ref Vector4 value, out Vector4 result)
+        {
+            float factor = (float)Math.Sqrt((value.X * value.X) + (value.Y * value.Y) + (value.Z * value.Z) + (value.W * value.W));
+            factor = 1f / factor;
+            result.W = value.W * factor;
+            result.X = value.X * factor;
+            result.Y = value.Y * factor;
+            result.Z = value.Z * factor;
+        }
+
+        /// <summary>
+        /// Round the members of this <see cref="Vector4"/> to the nearest integer value.
+        /// </summary>
+        public void Round()
+        {
+            X = (float)Math.Round(X);
+            Y = (float)Math.Round(Y);
+            Z = (float)Math.Round(Z);
+            W = (float)Math.Round(W);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains members from another vector rounded to the nearest integer value.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <returns>The rounded <see cref="Vector4"/>.</returns>
+        public static Vector4 Round(Vector4 value)
+        {
+            value.X = (float)Math.Round(value.X);
+            value.Y = (float)Math.Round(value.Y);
+            value.Z = (float)Math.Round(value.Z);
+            value.W = (float)Math.Round(value.W);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains members from another vector rounded to the nearest integer value.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <param name="result">The rounded <see cref="Vector4"/>.</param>
+        public static void Round(ref Vector4 value, out Vector4 result)
+        {
+            result.X = (float)Math.Round(value.X);
+            result.Y = (float)Math.Round(value.Y);
+            result.Z = (float)Math.Round(value.Z);
+            result.W = (float)Math.Round(value.W);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains cubic interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/>.</param>
+        /// <param name="value2">Source <see cref="Vector4"/>.</param>
+        /// <param name="amount">Weighting value.</param>
+        /// <returns>Cubic interpolation of the specified vectors.</returns>
+        public static Vector4 SmoothStep(Vector4 value1, Vector4 value2, float amount)
+        {
+            return new Vector4(
+                MathHelper.SmoothStep(value1.X, value2.X, amount),
+                MathHelper.SmoothStep(value1.Y, value2.Y, amount),
+                MathHelper.SmoothStep(value1.Z, value2.Z, amount),
+                MathHelper.SmoothStep(value1.W, value2.W, amount));
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains cubic interpolation of the specified vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/>.</param>
+        /// <param name="value2">Source <see cref="Vector4"/>.</param>
+        /// <param name="amount">Weighting value.</param>
+        /// <param name="result">Cubic interpolation of the specified vectors as an output parameter.</param>
+        public static void SmoothStep(ref Vector4 value1, ref Vector4 value2, float amount, out Vector4 result)
+        {
+            result.X = MathHelper.SmoothStep(value1.X, value2.X, amount);
+            result.Y = MathHelper.SmoothStep(value1.Y, value2.Y, amount);
+            result.Z = MathHelper.SmoothStep(value1.Z, value2.Z, amount);
+            result.W = MathHelper.SmoothStep(value1.W, value2.W, amount);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains subtraction of on <see cref="Vector4"/> from a another.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/>.</param>
+        /// <param name="value2">Source <see cref="Vector4"/>.</param>
+        /// <returns>The result of the vector subtraction.</returns>
+        public static Vector4 Subtract(Vector4 value1, Vector4 value2)
+        {
+            value1.W -= value2.W;
+            value1.X -= value2.X;
+            value1.Y -= value2.Y;
+            value1.Z -= value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains subtraction of on <see cref="Vector4"/> from a another.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/>.</param>
+        /// <param name="value2">Source <see cref="Vector4"/>.</param>
+        /// <param name="result">The result of the vector subtraction as an output parameter.</param>
+        public static void Subtract(ref Vector4 value1, ref Vector4 value2, out Vector4 result)
+        {
+            result.W = value1.W - value2.W;
+            result.X = value1.X - value2.X;
+            result.Y = value1.Y - value2.Y;
+            result.Z = value1.Z - value2.Z;
+        }
+
+        #region Transform
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a transformation of 2d-vector by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <returns>Transformed <see cref="Vector4"/>.</returns>
+        public static Vector4 Transform(Vector2 value, Matrix matrix)
+        {
+            Vector4 result;
+            Transform(ref value, ref matrix, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a transformation of 2d-vector by the specified <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <returns>Transformed <see cref="Vector4"/>.</returns>
+        public static Vector4 Transform(Vector2 value, Quaternion rotation)
+        {
+            Vector4 result;
+            Transform(ref value, ref rotation, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a transformation of 3d-vector by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <returns>Transformed <see cref="Vector4"/>.</returns>
+        public static Vector4 Transform(Vector3 value, Matrix matrix)
+        {
+            Vector4 result;
+            Transform(ref value, ref matrix, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a transformation of 3d-vector by the specified <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <returns>Transformed <see cref="Vector4"/>.</returns>
+        public static Vector4 Transform(Vector3 value, Quaternion rotation)
+        {
+            Vector4 result;
+            Transform(ref value, ref rotation, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a transformation of 4d-vector by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <returns>Transformed <see cref="Vector4"/>.</returns>
+        public static Vector4 Transform(Vector4 value, Matrix matrix)
+        {
+            Transform(ref value, ref matrix, out value);
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a transformation of 4d-vector by the specified <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <returns>Transformed <see cref="Vector4"/>.</returns>
+        public static Vector4 Transform(Vector4 value, Quaternion rotation)
+        {
+            Vector4 result;
+            Transform(ref value, ref rotation, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a transformation of 2d-vector by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="result">Transformed <see cref="Vector4"/> as an output parameter.</param>
+        public static void Transform(ref Vector2 value, ref Matrix matrix, out Vector4 result)
+        {
+            result.X = (value.X * matrix.M11) + (value.Y * matrix.M21) + matrix.M41;
+            result.Y = (value.X * matrix.M12) + (value.Y * matrix.M22) + matrix.M42;
+            result.Z = (value.X * matrix.M13) + (value.Y * matrix.M23) + matrix.M43;
+            result.W = (value.X * matrix.M14) + (value.Y * matrix.M24) + matrix.M44;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a transformation of 2d-vector by the specified <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector2"/>.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <param name="result">Transformed <see cref="Vector4"/> as an output parameter.</param>
+        public static void Transform(ref Vector2 value, ref Quaternion rotation, out Vector4 result)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a transformation of 3d-vector by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="result">Transformed <see cref="Vector4"/> as an output parameter.</param>
+        public static void Transform(ref Vector3 value, ref Matrix matrix, out Vector4 result)
+        {
+            result.X = (value.X * matrix.M11) + (value.Y * matrix.M21) + (value.Z * matrix.M31) + matrix.M41;
+            result.Y = (value.X * matrix.M12) + (value.Y * matrix.M22) + (value.Z * matrix.M32) + matrix.M42;
+            result.Z = (value.X * matrix.M13) + (value.Y * matrix.M23) + (value.Z * matrix.M33) + matrix.M43;
+            result.W = (value.X * matrix.M14) + (value.Y * matrix.M24) + (value.Z * matrix.M34) + matrix.M44;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a transformation of 3d-vector by the specified <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector3"/>.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <param name="result">Transformed <see cref="Vector4"/> as an output parameter.</param>
+        public static void Transform(ref Vector3 value, ref Quaternion rotation, out Vector4 result)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a transformation of 4d-vector by the specified <see cref="Matrix"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="result">Transformed <see cref="Vector4"/> as an output parameter.</param>
+        public static void Transform(ref Vector4 value, ref Matrix matrix, out Vector4 result)
+        {
+            var x = (value.X * matrix.M11) + (value.Y * matrix.M21) + (value.Z * matrix.M31) + (value.W * matrix.M41);
+            var y = (value.X * matrix.M12) + (value.Y * matrix.M22) + (value.Z * matrix.M32) + (value.W * matrix.M42);
+            var z = (value.X * matrix.M13) + (value.Y * matrix.M23) + (value.Z * matrix.M33) + (value.W * matrix.M43);
+            var w = (value.X * matrix.M14) + (value.Y * matrix.M24) + (value.Z * matrix.M34) + (value.W * matrix.M44);
+            result.X = x;
+            result.Y = y;
+            result.Z = z;
+            result.W = w;
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="Vector4"/> that contains a transformation of 4d-vector by the specified <see cref="Quaternion"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/>.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <param name="result">Transformed <see cref="Vector4"/> as an output parameter.</param>
+        public static void Transform(ref Vector4 value, ref Quaternion rotation, out Vector4 result)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// Apply transformation on vectors within array of <see cref="Vector4"/> by the specified <see cref="Matrix"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="sourceIndex">The starting index of transformation in the source array.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        /// <param name="destinationIndex">The starting index in the destination array, where the first <see cref="Vector4"/> should be written.</param>
+        /// <param name="length">The number of vectors to be transformed.</param>
+        public static void Transform
+        (
+            Vector4[] sourceArray,
+            int sourceIndex,
+            ref Matrix matrix,
+            Vector4[] destinationArray,
+            int destinationIndex,
+            int length
+        )
+        {
+            if (sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if (sourceArray.Length < sourceIndex + length)
+                throw new ArgumentException("Source array length is lesser than sourceIndex + length");
+            if (destinationArray.Length < destinationIndex + length)
+                throw new ArgumentException("Destination array length is lesser than destinationIndex + length");
+
+            for (var i = 0; i < length; i++)
+            {
+                var value = sourceArray[sourceIndex + i];
+                destinationArray[destinationIndex + i] = Transform(value, matrix);
+            }
+        }
+
+        /// <summary>
+        /// Apply transformation on vectors within array of <see cref="Vector4"/> by the specified <see cref="Quaternion"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="sourceIndex">The starting index of transformation in the source array.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        /// <param name="destinationIndex">The starting index in the destination array, where the first <see cref="Vector4"/> should be written.</param>
+        /// <param name="length">The number of vectors to be transformed.</param>
+        public static void Transform(
+            Vector4[] sourceArray,
+            int sourceIndex,
+            ref Quaternion rotation,
+            Vector4[] destinationArray,
+            int destinationIndex,
+            int length
+            )
+        {
+            if (sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if (sourceArray.Length < sourceIndex + length)
+                throw new ArgumentException("Source array length is lesser than sourceIndex + length");
+            if (destinationArray.Length < destinationIndex + length)
+                throw new ArgumentException("Destination array length is lesser than destinationIndex + length");
+
+            for (var i = 0; i < length; i++)
+            {
+                var value = sourceArray[sourceIndex + i];
+                destinationArray[destinationIndex + i] = Transform(value, rotation);
+            }
+        }
+
+        /// <summary>
+        /// Apply transformation on all vectors within array of <see cref="Vector4"/> by the specified <see cref="Matrix"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="matrix">The transformation <see cref="Matrix"/>.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        public static void Transform(Vector4[] sourceArray, ref Matrix matrix, Vector4[] destinationArray)
+        {
+            if (sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if (destinationArray.Length < sourceArray.Length)
+                throw new ArgumentException("Destination array length is lesser than source array length");
+
+            for (var i = 0; i < sourceArray.Length; i++)
+            {
+                var value = sourceArray[i];
+                destinationArray[i] = Transform(value, matrix);
+            }
+        }
+
+        /// <summary>
+        /// Apply transformation on all vectors within array of <see cref="Vector4"/> by the specified <see cref="Quaternion"/> and places the results in an another array.
+        /// </summary>
+        /// <param name="sourceArray">Source array.</param>
+        /// <param name="rotation">The <see cref="Quaternion"/> which contains rotation transformation.</param>
+        /// <param name="destinationArray">Destination array.</param>
+        public static void Transform(Vector4[] sourceArray, ref Quaternion rotation, Vector4[] destinationArray)
+        {
+            if (sourceArray == null)
+                throw new ArgumentNullException("sourceArray");
+            if (destinationArray == null)
+                throw new ArgumentNullException("destinationArray");
+            if (destinationArray.Length < sourceArray.Length)
+                throw new ArgumentException("Destination array length is lesser than source array length");
+
+            for (var i = 0; i < sourceArray.Length; i++)
+            {
+                var value = sourceArray[i];
+                destinationArray[i] = Transform(value, rotation);
+            }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Returns a <see cref="String"/> representation of this <see cref="Vector4"/> in the format:
+        /// {X:[<see cref="X"/>] Y:[<see cref="Y"/>] Z:[<see cref="Z"/>] W:[<see cref="W"/>]}
+        /// </summary>
+        /// <returns>A <see cref="String"/> representation of this <see cref="Vector4"/>.</returns>
+        public override string ToString()
+        {
+            return "{X:" + X + " Y:" + Y + " Z:" + Z + " W:" + W + "}";
+        }
+
+        /// <summary>
+        /// Deconstruction method for <see cref="Vector4"/>.
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <param name="z"></param>
+        /// <param name="w"></param>
+        public void Deconstruct(out float x, out float y, out float z, out float w)
+        {
+            x = X;
+            y = Y;
+            z = Z;
+            w = W;
+        }
+
+        #endregion
+
+        #region Operators
+
+        /// <summary>
+        /// Inverts values in the specified <see cref="Vector4"/>.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/> on the right of the sub sign.</param>
+        /// <returns>Result of the inversion.</returns>
+        public static Vector4 operator -(Vector4 value)
+        {
+            return new Vector4(-value.X, -value.Y, -value.Z, -value.W);
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="Vector4"/> instances are equal.
+        /// </summary>
+        /// <param name="value1"><see cref="Vector4"/> instance on the left of the equal sign.</param>
+        /// <param name="value2"><see cref="Vector4"/> instance on the right of the equal sign.</param>
+        /// <returns><c>true</c> if the instances are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Vector4 value1, Vector4 value2)
+        {
+            return value1.W == value2.W
+                && value1.X == value2.X
+                && value1.Y == value2.Y
+                && value1.Z == value2.Z;
+        }
+
+        /// <summary>
+        /// Compares whether two <see cref="Vector4"/> instances are not equal.
+        /// </summary>
+        /// <param name="value1"><see cref="Vector4"/> instance on the left of the not equal sign.</param>
+        /// <param name="value2"><see cref="Vector4"/> instance on the right of the not equal sign.</param>
+        /// <returns><c>true</c> if the instances are not equal; <c>false</c> otherwise.</returns>	
+        public static bool operator !=(Vector4 value1, Vector4 value2)
+        {
+            return !(value1 == value2);
+        }
+
+        /// <summary>
+        /// Adds two vectors.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/> on the left of the add sign.</param>
+        /// <param name="value2">Source <see cref="Vector4"/> on the right of the add sign.</param>
+        /// <returns>Sum of the vectors.</returns>
+        public static Vector4 operator +(Vector4 value1, Vector4 value2)
+        {
+            value1.W += value2.W;
+            value1.X += value2.X;
+            value1.Y += value2.Y;
+            value1.Z += value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Subtracts a <see cref="Vector4"/> from a <see cref="Vector4"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/> on the left of the sub sign.</param>
+        /// <param name="value2">Source <see cref="Vector4"/> on the right of the sub sign.</param>
+        /// <returns>Result of the vector subtraction.</returns>
+        public static Vector4 operator -(Vector4 value1, Vector4 value2)
+        {
+            value1.W -= value2.W;
+            value1.X -= value2.X;
+            value1.Y -= value2.Y;
+            value1.Z -= value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Multiplies the components of two vectors by each other.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/> on the left of the mul sign.</param>
+        /// <param name="value2">Source <see cref="Vector4"/> on the right of the mul sign.</param>
+        /// <returns>Result of the vector multiplication.</returns>
+        public static Vector4 operator *(Vector4 value1, Vector4 value2)
+        {
+            value1.W *= value2.W;
+            value1.X *= value2.X;
+            value1.Y *= value2.Y;
+            value1.Z *= value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Multiplies the components of vector by a scalar.
+        /// </summary>
+        /// <param name="value">Source <see cref="Vector4"/> on the left of the mul sign.</param>
+        /// <param name="scaleFactor">Scalar value on the right of the mul sign.</param>
+        /// <returns>Result of the vector multiplication with a scalar.</returns>
+        public static Vector4 operator *(Vector4 value, float scaleFactor)
+        {
+            value.W *= scaleFactor;
+            value.X *= scaleFactor;
+            value.Y *= scaleFactor;
+            value.Z *= scaleFactor;
+            return value;
+        }
+
+        /// <summary>
+        /// Multiplies the components of vector by a scalar.
+        /// </summary>
+        /// <param name="scaleFactor">Scalar value on the left of the mul sign.</param>
+        /// <param name="value">Source <see cref="Vector4"/> on the right of the mul sign.</param>
+        /// <returns>Result of the vector multiplication with a scalar.</returns>
+        public static Vector4 operator *(float scaleFactor, Vector4 value)
+        {
+            value.W *= scaleFactor;
+            value.X *= scaleFactor;
+            value.Y *= scaleFactor;
+            value.Z *= scaleFactor;
+            return value;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector4"/> by the components of another <see cref="Vector4"/>.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/> on the left of the div sign.</param>
+        /// <param name="value2">Divisor <see cref="Vector4"/> on the right of the div sign.</param>
+        /// <returns>The result of dividing the vectors.</returns>
+        public static Vector4 operator /(Vector4 value1, Vector4 value2)
+        {
+            value1.W /= value2.W;
+            value1.X /= value2.X;
+            value1.Y /= value2.Y;
+            value1.Z /= value2.Z;
+            return value1;
+        }
+
+        /// <summary>
+        /// Divides the components of a <see cref="Vector4"/> by a scalar.
+        /// </summary>
+        /// <param name="value1">Source <see cref="Vector4"/> on the left of the div sign.</param>
+        /// <param name="divider">Divisor scalar on the right of the div sign.</param>
+        /// <returns>The result of dividing a vector by a scalar.</returns>
+        public static Vector4 operator /(Vector4 value1, float divider)
+        {
+            float factor = 1f / divider;
+            value1.W *= factor;
+            value1.X *= factor;
+            value1.Y *= factor;
+            value1.Z *= factor;
+            return value1;
+        }
+
+        #endregion
+    }
+}
diff --git a/MonoGame.Framework/Web/WebGamePlatform.cs b/MonoGame.Framework/Web/WebGamePlatform.cs
new file mode 100644
index 00000000000..1f419e1837a
--- /dev/null
+++ b/MonoGame.Framework/Web/WebGamePlatform.cs
@@ -0,0 +1,111 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework.Input;
+using XnaKeys = Microsoft.Xna.Framework.Input.Keys;
+
+using JSIL;
+using JSIL.Meta;
+
+using MonoGame.Web;
+
+namespace Microsoft.Xna.Framework
+{
+    using MonoGame.Web;
+
+    public interface IHasCallback
+    {
+        void Callback();
+    }
+
+    class WebGamePlatform : GamePlatform, IHasCallback
+    {
+        private WebGameWindow _view;
+
+        public WebGamePlatform(Game game)
+            : base(game)
+        {
+            Window = new WebGameWindow(this);
+
+            _view = (WebGameWindow)Window;
+        }
+
+        public virtual void Callback()
+        {
+            this.Game.Tick();
+        }
+        
+        public override void Exit()
+        {
+        }
+
+        public override void RunLoop()
+        {
+            throw new InvalidOperationException("You can not run a synchronous loop on the web platform.");
+        }
+
+        public override void StartRunLoop()
+        {
+            ResetWindowBounds();
+            _view.window.setInterval((Action)(() => {
+                _view.ProcessEvents();
+                Game.Tick();
+            }), 25);
+        }
+
+        public override bool BeforeUpdate(GameTime gameTime)
+        {
+            return true;
+        }
+
+        public override bool BeforeDraw(GameTime gameTime)
+        {
+            return true;
+        }
+
+        public override void EnterFullScreen()
+        {
+            ResetWindowBounds();
+        }
+
+        public override void ExitFullScreen()
+        {
+            ResetWindowBounds();
+        }
+
+        internal void ResetWindowBounds()
+        {
+            var graphicsDeviceManager = (GraphicsDeviceManager)Game.Services.GetService(typeof(IGraphicsDeviceManager));
+
+            if (graphicsDeviceManager.IsFullScreen)
+            {
+                
+            }
+            else
+            {
+                _view.glcanvas.style.width = graphicsDeviceManager.PreferredBackBufferWidth + "px";
+                _view.glcanvas.style.height = graphicsDeviceManager.PreferredBackBufferHeight + "px";
+            }
+        }
+
+        public override void BeginScreenDeviceChange(bool willBeFullScreen)
+        {
+        }
+
+        public override void EndScreenDeviceChange(string screenDeviceName, int clientWidth, int clientHeight)
+        {
+        }
+
+        public override GameRunBehavior DefaultRunBehavior
+        {
+            get
+            {
+                return GameRunBehavior.Asynchronous;
+            }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Web/WebGameWindow.cs b/MonoGame.Framework/Web/WebGameWindow.cs
new file mode 100644
index 00000000000..cb03e611ba6
--- /dev/null
+++ b/MonoGame.Framework/Web/WebGameWindow.cs
@@ -0,0 +1,211 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using JSIL;
+using Microsoft.Xna.Framework.Input;
+using MonoGame.Web;
+
+namespace Microsoft.Xna.Framework
+{
+    class WebGameWindow : GameWindow
+    {
+        private WebGamePlatform _platform;
+        private List<Keys> _keys;
+
+        public dynamic document, glcanvas, gl, window;
+
+        private Action<dynamic> _onmousemove, _onmousedown, _onmouseup, _onkeydown, _onkeyup, _onwheel;
+
+        public WebGameWindow(WebGamePlatform platform)
+        {
+            _platform = platform;
+            _keys = new List<Keys>();
+
+            _onmousemove = (Action<dynamic>)OnMouseMove;
+            _onmousedown = (Action<dynamic>)OnMouseDown;
+            _onmouseup = (Action<dynamic>)OnMouseUp;
+            _onkeydown = (Action<dynamic>)OnKeyDown;
+            _onkeyup = (Action<dynamic>)OnKeyUp;
+            _onwheel = (Action<dynamic>)OnMouseWheel;
+            
+            document = Builtins.Global["document"];
+            window = Builtins.Global["window"];
+            glcanvas = document.getElementById("mgcanvas");
+            gl = glcanvas.getContext("webgl");
+
+            WebGL.gl = gl;
+
+            if (glcanvas.mozRequestPointerLock)
+                glcanvas.requestPointerLock = glcanvas.mozRequestPointerLock;
+            else if(glcanvas.webkitRequestPointerLock)
+                glcanvas.requestPointerLock = glcanvas.webkitRequestPointerLock;
+
+            document.addEventListener("pointerlockchange", (Action)OnCursorLockChange, false);
+            document.addEventListener("mozpointerlockchange", (Action)OnCursorLockChange, false);
+            document.addEventListener("webkitpointerlockchange", (Action)OnCursorLockChange, false);
+
+            glcanvas.addEventListener("contextmenu", (Action<dynamic>)((e) => e.preventDefault()), false);
+
+            glcanvas.onclick = (Action<dynamic>)OnMouseClick;
+
+            Mouse.PrimaryWindow = this;
+        }
+
+        private void OnCursorLockChange()
+        {
+            if (document.pointerLockElement == glcanvas || document.mozPointerLockElement == glcanvas || document.webkitPointerLockElement == glcanvas)
+            {
+                document.addEventListener("mousemove", _onmousemove, false);
+                document.addEventListener("mousedown", _onmousedown, false);
+                document.addEventListener("mouseup", _onmouseup, false);
+                glcanvas.addEventListener("wheel", _onwheel, false);
+                document.addEventListener("keydown", _onkeydown, false);
+                document.addEventListener("keyup", _onkeyup, false);
+
+                Joystick.TrackEvents = true;
+            }
+            else
+            {
+                document.removeEventListener("mousemove", _onmousemove, false);
+                document.removeEventListener("mousedown", _onmousedown, false);
+                document.removeEventListener("mouseup", _onmouseup, false);
+                glcanvas.removeEventListener("wheel", _onwheel, false);
+                document.removeEventListener("keydown", _onkeydown, false);
+                document.removeEventListener("keyup", _onkeyup, false);
+
+                Joystick.TrackEvents = false;
+            }
+        }
+
+        private void OnMouseClick(dynamic e)
+        {
+            glcanvas.requestPointerLock();
+        }
+
+        private void OnMouseMove(dynamic e)
+        {
+            var movementX = e.movementX || e.mozMovementX || e.webkitMovementX || 0;
+            var movementY = e.movementY || e.mozMovementY || e.webkitMovementY || 0;
+
+            this.MouseState.X = Math.Min(Math.Max(this.MouseState.X + movementX, 0), glcanvas.clientWidth);
+            this.MouseState.Y = Math.Min(Math.Max(this.MouseState.Y + movementY, 0), glcanvas.clientHeight);
+        }
+
+        private void OnMouseDown(dynamic e)
+        {
+            if (e.button == 0)
+                this.MouseState.LeftButton = ButtonState.Pressed;
+            else if (e.button == 1)
+                this.MouseState.MiddleButton = ButtonState.Pressed;
+            else if (e.button == 2)
+                this.MouseState.RightButton = ButtonState.Pressed;
+        }
+
+        private void OnMouseUp(dynamic e)
+        {
+            if (e.button == 0)
+                this.MouseState.LeftButton = ButtonState.Released;
+            else if (e.button == 1)
+                this.MouseState.MiddleButton = ButtonState.Released;
+            else if (e.button == 2)
+                this.MouseState.RightButton = ButtonState.Released;
+        }
+
+        private void OnMouseWheel(dynamic e)
+        {
+            if (e.deltaY < 0)
+                this.MouseState.ScrollWheelValue += 120;
+            else
+                this.MouseState.ScrollWheelValue -= 120;
+        }
+
+        private void OnKeyDown(dynamic e)
+        {
+            Keys xnaKey = KeyboardUtil.ToXna(e.keyCode, e.location);
+
+            if (!_keys.Contains(xnaKey))
+                _keys.Add(xnaKey);
+        }
+
+        private void OnKeyUp(dynamic e)
+        {
+            Keys xnaKey = KeyboardUtil.ToXna(e.keyCode, e.location);
+
+            if (_keys.Contains(xnaKey))
+                _keys.Remove(xnaKey);
+        }
+
+        internal void ProcessEvents()
+        {
+            Keyboard.SetKeys(_keys);
+        }
+
+        public override void BeginScreenDeviceChange(bool willBeFullScreen)
+        {
+        }
+
+        public override void EndScreenDeviceChange(string screenDeviceName, int clientWidth, int clientHeight)
+        {
+        }
+
+        protected internal override void SetSupportedOrientations(DisplayOrientation orientations)
+        {
+        }
+
+        protected override void SetTitle(string title)
+        {
+            Builtins.Eval("window.title = '" + title + "';");
+        }
+
+        public override bool AllowUserResizing
+        {
+            get
+            {
+                return false;
+            }
+            set
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        public override Rectangle ClientBounds
+        {
+            get
+            {
+                int width = glcanvas.clientWidth;
+                int height = glcanvas.clientHeight;
+
+                return new Rectangle(0, 0, width, height);
+            }
+        }
+
+        public override DisplayOrientation CurrentOrientation
+        {
+            get
+            {
+                return DisplayOrientation.Default;
+            }
+        }
+
+        public override IntPtr Handle
+        {
+            get
+            {
+                return IntPtr.Zero;
+            }
+        }
+
+        public override string ScreenDeviceName
+        {
+            get
+            {
+                return string.Empty;
+            }
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/Web/WebHelper.cs b/MonoGame.Framework/Web/WebHelper.cs
new file mode 100644
index 00000000000..e389c307fc6
--- /dev/null
+++ b/MonoGame.Framework/Web/WebHelper.cs
@@ -0,0 +1,12 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace MonoGame.Web
+{
+    public static class WebGL
+    {
+        public static dynamic gl;
+    }
+}
+
diff --git a/MonoGame.Framework/Windows/GamerServices/Guide.cs b/MonoGame.Framework/Windows/GamerServices/Guide.cs
new file mode 100644
index 00000000000..7273dfced9e
--- /dev/null
+++ b/MonoGame.Framework/Windows/GamerServices/Guide.cs
@@ -0,0 +1,427 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+#region Using clause
+
+using MGXna_Framework = global::Microsoft.Xna.Framework;
+
+using System;
+using System.Collections.Generic;
+
+#if WINDOWS_UAP
+using System.Threading.Tasks;
+using Windows.ApplicationModel;
+using Windows.ApplicationModel.Store;
+using Windows.UI.Core;
+using Windows.UI.Popups;
+using Windows.System;
+using Microsoft.Xna.Framework.Input;
+#else
+using System.Runtime.Remoting.Messaging;
+#if !(WINDOWS && DIRECTX)
+using Microsoft.Xna.Framework.Net;
+#endif
+#endif
+
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+
+
+	public static class Guide
+	{
+		private static bool isScreenSaverEnabled;
+		private static bool isTrialMode = false;
+		private static bool isVisible;
+		private static bool simulateTrialMode;
+
+#if WINDOWS_UAP
+	    private static readonly CoreDispatcher _dispatcher;
+#endif 
+
+        static Guide()
+        {
+#if WINDOWS_UAP
+            _dispatcher = Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher;
+
+
+            var licenseInformation = CurrentApp.LicenseInformation;
+            licenseInformation.LicenseChanged += () => isTrialMode = !licenseInformation.IsActive || licenseInformation.IsTrial;
+
+            isTrialMode = !licenseInformation.IsActive || licenseInformation.IsTrial;
+#endif
+        }
+
+		delegate string ShowKeyboardInputDelegate(
+         MGXna_Framework.PlayerIndex player,           
+         string title,
+         string description,
+         string defaultText,
+		 bool usePasswordMode);
+
+		private static string ShowKeyboardInput(
+         MGXna_Framework.PlayerIndex player,           
+         string title,
+         string description,
+         string defaultText,
+		 bool usePasswordMode)
+        {
+            throw new NotImplementedException();
+		}
+
+		public static IAsyncResult BeginShowKeyboardInput (
+         MGXna_Framework.PlayerIndex player,
+         string title,
+         string description,
+         string defaultText,
+         AsyncCallback callback,
+         Object state)
+		{
+		return BeginShowKeyboardInput(player, title, description, defaultText, callback, state, false );
+		}
+
+		public static IAsyncResult BeginShowKeyboardInput (
+         MGXna_Framework.PlayerIndex player,
+         string title,
+         string description,
+         string defaultText,
+         AsyncCallback callback,
+         Object state,
+         bool usePasswordMode)
+		{
+#if !WINDOWS_UAP
+			ShowKeyboardInputDelegate ski = ShowKeyboardInput; 
+
+			return ski.BeginInvoke(player, title, description, defaultText, usePasswordMode, callback, ski);
+#else
+            throw new NotImplementedException();
+#endif
+		}
+
+		public static string EndShowKeyboardInput (IAsyncResult result)
+		{
+#if !WINDOWS_UAP
+			ShowKeyboardInputDelegate ski = (ShowKeyboardInputDelegate)result.AsyncState; 
+
+			return ski.EndInvoke(result);		
+#else
+            throw new NotImplementedException();
+#endif
+		}
+
+        delegate Nullable<int> ShowMessageBoxDelegate(string title,
+         string text,
+         IEnumerable<string> buttons,
+         int focusButton,
+         MessageBoxIcon icon);
+
+        private static Nullable<int> ShowMessageBox(string title,
+         string text,
+         IEnumerable<string> buttons,
+         int focusButton,
+         MessageBoxIcon icon)
+        {
+            int? result = null;
+            IsVisible = true;
+
+#if WINDOWS_UAP
+
+            MessageDialog dialog = new MessageDialog(text, title);
+            foreach (string button in buttons)
+                dialog.Commands.Add(new UICommand(button, null, dialog.Commands.Count));
+
+            if (focusButton < 0 || focusButton >= dialog.Commands.Count)
+                throw new ArgumentOutOfRangeException("focusButton", "Specified argument was out of the range of valid values.");
+            dialog.DefaultCommandIndex = (uint)focusButton;
+
+            // The message box must be popped up on the UI thread.
+            Task<IUICommand> dialogResult = null;
+            _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
+            {
+                dialogResult = dialog.ShowAsync().AsTask();
+            }).AsTask().Wait();
+
+            dialogResult.Wait();
+            result = (int)dialogResult.Result.Id;
+
+#endif
+            IsVisible = false;
+            return result;
+        }
+
+        public static IAsyncResult BeginShowMessageBox(
+         MGXna_Framework.PlayerIndex player,
+         string title,
+         string text,
+         IEnumerable<string> buttons,
+         int focusButton,
+         MessageBoxIcon icon,
+         AsyncCallback callback,
+         Object state
+        )
+        {
+#if !WINDOWS_UAP
+            // TODO: GuideAlreadyVisibleException
+            if (IsVisible)
+                throw new Exception("The function cannot be completed at this time: the Guide UI is already active. Wait until Guide.IsVisible is false before issuing this call.");
+
+            if (player != PlayerIndex.One)
+                throw new ArgumentOutOfRangeException("player", "Specified argument was out of the range of valid values.");
+            if (title == null)
+                throw new ArgumentNullException("title", "This string cannot be null or empty, and must be less than 256 characters long.");
+            if (text == null)
+                throw new ArgumentNullException("text", "This string cannot be null or empty, and must be less than 256 characters long.");
+            if (buttons == null)
+                throw new ArgumentNullException("buttons", "Value can not be null.");
+
+            ShowMessageBoxDelegate smb = ShowMessageBox;
+
+            return smb.BeginInvoke(title, text, buttons, focusButton, icon, callback, smb);
+#else
+
+            var tcs = new TaskCompletionSource<int?>(state);
+            var task = Task.Run<int?>(() => ShowMessageBox(title, text, buttons, focusButton, icon));
+            task.ContinueWith(t =>
+            {
+                // Copy the task result into the returned task.
+                if (t.IsFaulted)
+                    tcs.TrySetException(t.Exception.InnerExceptions);
+                else if (t.IsCanceled)
+                    tcs.TrySetCanceled();
+                else
+                    tcs.TrySetResult(t.Result);
+
+                // Invoke the user callback if necessary.
+                if (callback != null)
+                    callback(tcs.Task);
+            });
+            return tcs.Task;
+#endif
+        }
+
+        public static IAsyncResult BeginShowMessageBox(
+         string title,
+         string text,
+         IEnumerable<string> buttons,
+         int focusButton,
+         MessageBoxIcon icon,
+         AsyncCallback callback,
+         Object state
+        )
+        {
+            return BeginShowMessageBox(MGXna_Framework.PlayerIndex.One, title, text, buttons, focusButton, icon, callback, state);
+        }
+
+        public static Nullable<int> EndShowMessageBox(IAsyncResult result)
+        {
+#if WINDOWS_UAP
+            var x = (Task<int?>)result;
+            return  x.Result;
+#else
+            return ((ShowMessageBoxDelegate)result.AsyncState).EndInvoke(result);
+#endif
+        }
+
+        public static void ShowMarketplace(MGXna_Framework.PlayerIndex player)
+        {
+        }
+
+		public static void Show ()
+		{
+			ShowSignIn(1, false);
+		}
+
+		public static void ShowSignIn (int paneCount, bool onlineOnly)
+		{
+			if ( paneCount != 1 && paneCount != 2 && paneCount != 4)
+			{
+				new ArgumentException("paneCount Can only be 1, 2 or 4 on Windows");
+				return;
+			}
+
+#if !WINDOWS_UAP && !(WINDOWS && DIRECTX)
+            Microsoft.Xna.Framework.GamerServices.MonoGameGamerServicesHelper.ShowSigninSheet();            
+
+            if (GamerServicesComponent.LocalNetworkGamer == null)
+            {
+                GamerServicesComponent.LocalNetworkGamer = new LocalNetworkGamer();
+            }
+            else
+            {
+                GamerServicesComponent.LocalNetworkGamer.SignedInGamer.BeginAuthentication(null, null);
+            }
+#endif
+		}
+
+		public static void ShowLeaderboard()
+		{
+            //if ( ( Gamer.SignedInGamers.Count > 0 ) && ( Gamer.SignedInGamers[0].IsSignedInToLive ) )
+            //{
+            //    // Lazy load it
+            //    if ( leaderboardController == null )
+            //    {			    	
+            //        leaderboardController = new GKLeaderboardViewController();
+            //    }
+
+            //    if (leaderboardController != null)			
+            //    {
+            //        leaderboardController.DidFinish += delegate(object sender, EventArgs e) 
+            //        {
+            //            leaderboardController.DismissModalViewControllerAnimated(true);
+            //            isVisible = false;
+            //        };
+
+            //        if (Window !=null)
+            //        {						
+            //            if(viewController == null)
+            //            {
+            //                viewController = new UIViewController();
+            //                Window.Add(viewController.View);
+            //                viewController.View.Hidden = true;
+            //            }
+
+            //            viewController.PresentModalViewController(leaderboardController, true);
+            //            isVisible = true;
+            //        }
+            //    }
+            //}
+		}
+
+		public static void ShowAchievements()
+		{
+            //if ( ( Gamer.SignedInGamers.Count > 0 ) && ( Gamer.SignedInGamers[0].IsSignedInToLive ) )
+            //{
+            //    // Lazy load it
+            //    if ( achievementController == null )
+            //    {
+            //        achievementController = new GKAchievementViewController();
+            //    }
+
+            //    if (achievementController != null)		
+            //    {					
+            //        achievementController.DidFinish += delegate(object sender, EventArgs e) 
+            //        {									 
+            //            leaderboardController.DismissModalViewControllerAnimated(true);
+            //            isVisible = false;
+            //        };
+
+            //        if (Window !=null)
+            //        {
+            //            if(viewController == null)
+            //            {
+            //                viewController = new UIViewController();
+            //                Window.Add(viewController.View);
+            //                viewController.View.Hidden = true;
+            //            }
+
+            //            viewController.PresentModalViewController(achievementController, true);						
+            //            isVisible = true;
+            //        }
+            //    }
+            //}
+		}
+
+		#region Properties
+		public static bool IsScreenSaverEnabled 
+		{ 
+			get
+			{
+				return isScreenSaverEnabled;
+			}
+			set
+			{
+				isScreenSaverEnabled = value;
+			}
+		}
+
+		public static bool IsTrialMode 
+		{ 
+			get
+			{
+				// If simulate trial mode is enabled then 
+				// we're in the trial mode.
+#if DEBUG
+                return simulateTrialMode || isTrialMode;
+#else
+                return simulateTrialMode || isTrialMode;
+#endif
+			}
+		}
+
+		public static bool IsVisible 
+		{ 
+			get
+			{
+				return isVisible;
+			}
+			set
+			{
+				isVisible = value;
+			}
+		}
+
+		public static bool SimulateTrialMode 
+		{ 
+			get
+			{
+				return simulateTrialMode;
+			}
+			set
+			{
+				simulateTrialMode = value;
+			}
+		}
+
+		public static MGXna_Framework.GameWindow Window 
+		{ 
+			get;
+			set;
+		}
+		#endregion
+
+        internal static void Initialise(MGXna_Framework.Game game)
+        {
+#if !DIRECTX
+            MonoGameGamerServicesHelper.Initialise(game);
+#endif
+        }
+    }
+}
diff --git a/MonoGame.Framework/Windows/GamerServices/MonoGameGamerServicesHelper.cs b/MonoGame.Framework/Windows/GamerServices/MonoGameGamerServicesHelper.cs
new file mode 100644
index 00000000000..86be11aeaeb
--- /dev/null
+++ b/MonoGame.Framework/Windows/GamerServices/MonoGameGamerServicesHelper.cs
@@ -0,0 +1,151 @@
+using System;
+using Microsoft.Xna.Framework.Graphics;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    internal class MonoGameGamerServicesHelper
+    {
+        private static MonoLiveGuide guide = null;
+
+        
+
+        public static void ShowSigninSheet()
+        {
+            guide.Enabled = true;
+            guide.Visible = true;
+            Guide.IsVisible = true;
+        }
+    
+        internal static void Initialise(Game game)
+        {
+            if (guide == null)
+            {
+                guide = new MonoLiveGuide(game);                
+                game.Components.Add(guide);
+            }
+        }}
+
+    internal class MonoLiveGuide : DrawableGameComponent
+    {
+        SpriteBatch spriteBatch;
+        Texture2D signInProgress;
+        Color alphaColor = new Color(128, 128, 128, 0);
+        byte startalpha = 0;
+
+        public MonoLiveGuide(Game game)
+            : base(game)
+        {
+            this.Enabled = false;
+            this.Visible = false;
+            //Guide.IsVisible = false;
+            this.DrawOrder = Int32.MaxValue;
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+        }
+
+        Texture2D Circle(GraphicsDevice graphics, int radius)
+        {
+            int aDiameter = radius * 2;
+            Vector2 aCenter = new Vector2(radius, radius);
+
+            Texture2D aCircle = new Texture2D(graphics, aDiameter, aDiameter, false, SurfaceFormat.Color);
+            Color[] aColors = new Color[aDiameter * aDiameter];
+
+            for (int i = 0; i < aColors.Length; i++)
+            {
+                int x = (i + 1) % aDiameter;
+                int y = (i + 1) / aDiameter;
+
+                Vector2 aDistance = new Vector2(Math.Abs(aCenter.X - x), Math.Abs(aCenter.Y - y));
+
+
+                if (Math.Sqrt((aDistance.X * aDistance.X) + (aDistance.Y * aDistance.Y)) > radius)
+                {
+                    aColors[i] = Color.Transparent;
+                }
+                else
+                {
+                    aColors[i] = Color.White;
+                }
+            }
+
+            aCircle.SetData<Color>(aColors);
+
+            return aCircle;
+        }
+
+        protected override void LoadContent()
+        {
+            spriteBatch = new SpriteBatch(this.Game.GraphicsDevice);
+
+            signInProgress = Circle(this.Game.GraphicsDevice, 10);
+
+            base.LoadContent();
+        }
+
+        protected override void UnloadContent()
+        {
+            base.UnloadContent();
+        }
+
+        public override void Draw(GameTime gameTime)
+        {
+            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend);
+
+            Vector2 center = new Vector2(this.Game.GraphicsDevice.PresentationParameters.BackBufferWidth / 2, this.Game.GraphicsDevice.PresentationParameters.BackBufferHeight - 100);
+            Vector2 loc = Vector2.Zero;
+            alphaColor.A = startalpha;
+            for (int i = 0; i < 12; i++)
+            {
+                float angle = (float)(i / 12.0 * Math.PI * 2);
+                loc = new Vector2(center.X + (float)Math.Cos(angle) * 50, center.Y + (float)Math.Sin(angle) * 50);
+                spriteBatch.Draw(signInProgress, loc, alphaColor);
+                alphaColor.A += 255 / 12;
+                if (alphaColor.A > 255) alphaColor.A = 0;
+            }
+            spriteBatch.End();
+            base.Draw(gameTime);
+        }
+
+        TimeSpan gt = TimeSpan.Zero;
+        TimeSpan last = TimeSpan.Zero;
+
+        public override void Update(GameTime gameTime)
+        {
+            if (gt == TimeSpan.Zero) gt = last = gameTime.TotalGameTime;
+
+            if ((gameTime.TotalGameTime - last).Milliseconds > 100)
+            {
+                last = gameTime.TotalGameTime;
+                startalpha += 255 / 12;
+            }
+
+            if ((gameTime.TotalGameTime - gt).TotalSeconds > 5) // close after 10 seconds
+            {
+                string strUsr = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
+
+                if (strUsr.Contains(@"\"))
+                {
+                    int idx = strUsr.IndexOf(@"\") + 1;
+                    strUsr = strUsr.Substring(idx, strUsr.Length - idx);
+                }
+
+                SignedInGamer sig = new SignedInGamer();
+                sig.DisplayName = strUsr;
+                sig.Gamertag = strUsr;
+
+                Gamer.SignedInGamers.Add(sig);
+
+                this.Visible = false;
+                this.Enabled = false;
+                //Guide.IsVisible = false;
+                gt = TimeSpan.Zero;
+            }
+            base.Update(gameTime);
+        }
+
+    }
+}
diff --git a/MonoGame.Framework/Windows/GamerServices/SignedInGamer.cs b/MonoGame.Framework/Windows/GamerServices/SignedInGamer.cs
new file mode 100644
index 00000000000..6f56ae82305
--- /dev/null
+++ b/MonoGame.Framework/Windows/GamerServices/SignedInGamer.cs
@@ -0,0 +1,327 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+#region Statement
+using System;
+
+#endregion Statement
+
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    public class SignedInGamer : Gamer
+    {		
+		private AchievementCollection gamerAchievements;
+		private FriendCollection friendCollection;
+		
+		delegate void AuthenticationDelegate();
+		
+		public IAsyncResult BeginAuthentication(AsyncCallback callback, Object asyncState)
+		{
+			// Go off authenticate
+			AuthenticationDelegate ad = DoAuthentication; 
+			
+			return ad.BeginInvoke(callback, ad);
+		}
+		
+		public void EndAuthentication( IAsyncResult result )
+		{
+			AuthenticationDelegate ad = (AuthenticationDelegate)result.AsyncState; 
+			
+			ad.EndInvoke(result);
+		}
+		
+		private void DoAuthentication()
+		{
+				
+		}
+		
+		public SignedInGamer()
+		{
+			
+			var result = BeginAuthentication(null, null);	
+			EndAuthentication( result );
+		}
+		
+		private void AuthenticationCompletedCallback( IAsyncResult result )
+		{
+			EndAuthentication(result);	
+		}
+		
+		#region Methods
+		public FriendCollection GetFriends()
+		{
+			if(IsSignedInToLive)
+			{
+				if ( friendCollection == null )
+				{
+					friendCollection = new FriendCollection();
+				}
+								
+			}
+			
+			return friendCollection;
+		}
+		
+		public bool IsFriend (Gamer gamer)
+		{
+			if ( gamer == null ) 
+				throw new ArgumentNullException();
+			
+			if ( gamer.IsDisposed )
+				throw new ObjectDisposedException(gamer.ToString());	
+			
+			bool found = false;
+			foreach(FriendGamer f in friendCollection)
+			{
+				if ( f.Gamertag == gamer.Gamertag )
+				{
+					found = true;
+				}
+			}
+			return found;
+						
+		}
+		
+		delegate AchievementCollection GetAchievementsDelegate();
+		
+		public IAsyncResult BeginGetAchievements( AsyncCallback callback, Object asyncState)
+		{
+			// Go off and grab achievements
+			GetAchievementsDelegate gad = GetAchievements; 
+			
+			return gad.BeginInvoke(callback, gad);
+		}
+		
+		private void GetAchievementCompletedCallback( IAsyncResult result )
+		{
+			// get the delegate that was used to call that method
+			GetAchievementsDelegate gad = (GetAchievementsDelegate)result.AsyncState; 
+
+			// get the return value from that method call
+			gamerAchievements = gad.EndInvoke(result);
+		}
+		
+		public AchievementCollection EndGetAchievements( IAsyncResult result )
+		{
+			GetAchievementsDelegate gad = (GetAchievementsDelegate)result.AsyncState; 
+			
+			gamerAchievements = gad.EndInvoke(result);
+			
+			return gamerAchievements;
+		}
+		
+		public AchievementCollection GetAchievements()
+		{
+			if ( IsSignedInToLive )
+			{
+				if (gamerAchievements == null)
+				{
+					gamerAchievements = new AchievementCollection();
+				}
+								
+			}
+			return gamerAchievements;
+		}
+		
+		delegate void AwardAchievementDelegate(string achievementId, double percentageComplete);
+
+        public IAsyncResult BeginAwardAchievement(string achievementId, AsyncCallback callback, Object state)
+        {
+            return BeginAwardAchievement(achievementId, 100.0, callback, state);
+        }
+
+        public IAsyncResult BeginAwardAchievement(
+         string achievementId,
+		 double percentageComplete,
+         AsyncCallback callback,
+         Object state
+		)
+		{	
+			// Go off and award the achievement
+			AwardAchievementDelegate aad = DoAwardAchievement; 
+				
+			return aad.BeginInvoke(achievementId, percentageComplete, callback, aad);
+		}
+		
+		public void EndAwardAchievement(IAsyncResult result)
+		{
+			AwardAchievementDelegate aad = (AwardAchievementDelegate)result.AsyncState; 
+			
+			aad.EndInvoke(result);
+		}
+		
+		private void AwardAchievementCompletedCallback( IAsyncResult result )
+		{
+			EndAwardAchievement(result);	
+		}
+		
+		public void AwardAchievement( string achievementId )
+		{			
+			AwardAchievement(achievementId, 100.0f);
+		}
+		
+		public void DoAwardAchievement( string achievementId, double percentageComplete )
+		{			
+		}
+		
+		public void AwardAchievement( string achievementId, double percentageComplete )
+		{
+			if (IsSignedInToLive)
+			{
+				BeginAwardAchievement( achievementId, percentageComplete, AwardAchievementCompletedCallback, null );
+			}
+		}
+		
+		public void UpdateScore( string aCategory, long aScore )
+		{
+			if (IsSignedInToLive)
+			{				
+			}
+		}
+		
+		public void ResetAchievements()
+		{
+			if (IsSignedInToLive)
+			{				
+			}
+		}
+
+		#endregion
+			
+		#region Properties
+		public GameDefaults GameDefaults 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+		
+		public bool IsGuest 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+		
+		public bool IsSignedInToLive 
+		{ 
+			get
+			{
+				return false;
+			}
+		}
+		
+		public int PartySize 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+			set
+			{
+				throw new NotSupportedException();
+			}
+		}
+		
+        public PlayerIndex PlayerIndex
+        {
+            get
+            {
+                return PlayerIndex.One;
+            }
+        }
+		
+		public GamerPresence Presence 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+
+        GamerPrivileges _privileges = new GamerPrivileges();
+        public GamerPrivileges Privileges
+        {
+            get
+            {
+                return _privileges;
+            }
+        }
+		#endregion
+		
+		
+		protected virtual void OnSignedIn(SignedInEventArgs e)
+		{
+            EventHelpers.Raise(this, SignedIn, e);
+		}
+		
+		protected virtual void OnSignedOut(SignedOutEventArgs e)
+		{
+		    EventHelpers.Raise(this, SignedOut, e);
+		}
+
+		
+		#region Events
+		public static event EventHandler<SignedInEventArgs> SignedIn;
+		
+		public static event EventHandler<SignedOutEventArgs> SignedOut;
+		#endregion
+    }
+	
+	public class SignedInEventArgs : EventArgs
+	{
+		public SignedInEventArgs ( SignedInGamer gamer )
+		{
+			
+		}
+	}
+	
+	public class SignedOutEventArgs : EventArgs
+	{
+		public SignedOutEventArgs (SignedInGamer gamer )
+		{
+			
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/Windows/HorizontalMouseWheelEventArgs.cs b/MonoGame.Framework/Windows/HorizontalMouseWheelEventArgs.cs
new file mode 100644
index 00000000000..1fbbb27c15e
--- /dev/null
+++ b/MonoGame.Framework/Windows/HorizontalMouseWheelEventArgs.cs
@@ -0,0 +1,14 @@
+using System;
+
+namespace Microsoft.Xna.Framework.Windows
+{
+    internal class HorizontalMouseWheelEventArgs : EventArgs
+    {
+        internal int Delta { get; private set; }
+
+        internal HorizontalMouseWheelEventArgs(int delta)
+        {
+            Delta = delta;
+        }
+    }
+}
diff --git a/MonoGame.Framework/Windows/SharpDXHelper.cs b/MonoGame.Framework/Windows/SharpDXHelper.cs
new file mode 100644
index 00000000000..70f5ed48adc
--- /dev/null
+++ b/MonoGame.Framework/Windows/SharpDXHelper.cs
@@ -0,0 +1,184 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+namespace Microsoft.Xna.Framework
+{
+    using System;
+    using Graphics;
+    using SharpDX.Mathematics.Interop;
+
+    static internal class SharpDXHelper
+    {
+        static public SharpDX.DXGI.SwapEffect ToSwapEffect(PresentInterval presentInterval)
+        {
+            SharpDX.DXGI.SwapEffect effect;
+
+            switch (presentInterval)
+            {
+                case PresentInterval.One:
+                case PresentInterval.Two:
+                default:
+#if WINDOWS_UAP
+                    effect = SharpDX.DXGI.SwapEffect.FlipSequential;
+#else
+                    effect = SharpDX.DXGI.SwapEffect.Discard;
+#endif
+                    break;
+
+                case PresentInterval.Immediate:
+                    effect = SharpDX.DXGI.SwapEffect.Sequential;
+                    break;
+            }
+
+            //if (present.RenderTargetUsage != RenderTargetUsage.PreserveContents && present.MultiSampleCount == 0)
+            //effect = SharpDX.DXGI.SwapEffect.Discard;
+
+            return effect;
+        }
+
+        static public SharpDX.DXGI.Format ToFormat(DepthFormat format)
+        {
+            switch (format)
+            {
+                default:
+                case DepthFormat.None:
+                    return SharpDX.DXGI.Format.Unknown;
+
+                case DepthFormat.Depth16:
+                    return SharpDX.DXGI.Format.D16_UNorm;
+
+                case DepthFormat.Depth24:
+                case DepthFormat.Depth24Stencil8:
+                    return SharpDX.DXGI.Format.D24_UNorm_S8_UInt;
+            }
+        }
+
+        static public SharpDX.DXGI.Format ToFormat(SurfaceFormat format)
+        {
+            switch (format)
+            {
+                case SurfaceFormat.Color:
+                default:
+                    return SharpDX.DXGI.Format.R8G8B8A8_UNorm;
+
+                case SurfaceFormat.Bgr565:
+                    return SharpDX.DXGI.Format.B5G6R5_UNorm;
+                case SurfaceFormat.Bgra5551:
+                    return SharpDX.DXGI.Format.B5G5R5A1_UNorm;
+                case SurfaceFormat.Bgra4444:
+#if WINDOWS_UAP
+                    return SharpDX.DXGI.Format.B4G4R4A4_UNorm;
+#else
+                    return (SharpDX.DXGI.Format)115;
+#endif
+                case SurfaceFormat.Dxt1:
+                    return SharpDX.DXGI.Format.BC1_UNorm;
+                case SurfaceFormat.Dxt3:
+                    return SharpDX.DXGI.Format.BC2_UNorm;
+                case SurfaceFormat.Dxt5:
+                    return SharpDX.DXGI.Format.BC3_UNorm;
+                case SurfaceFormat.NormalizedByte2:
+                    return SharpDX.DXGI.Format.R8G8_SNorm;
+                case SurfaceFormat.NormalizedByte4:
+                    return SharpDX.DXGI.Format.R8G8B8A8_SNorm;
+                case SurfaceFormat.Rgba1010102:
+                    return SharpDX.DXGI.Format.R10G10B10A2_UNorm;
+                case SurfaceFormat.Rg32:
+                    return SharpDX.DXGI.Format.R16G16_UNorm;
+                case SurfaceFormat.Rgba64:
+                    return SharpDX.DXGI.Format.R16G16B16A16_UNorm;
+                case SurfaceFormat.Alpha8:
+                    return SharpDX.DXGI.Format.A8_UNorm;
+                case SurfaceFormat.Single:
+                    return SharpDX.DXGI.Format.R32_Float;
+                case SurfaceFormat.HalfSingle:
+                    return SharpDX.DXGI.Format.R16_Float;
+                case SurfaceFormat.HalfVector2:
+                    return SharpDX.DXGI.Format.R16G16_Float;
+                case SurfaceFormat.Vector2:
+                    return SharpDX.DXGI.Format.R32G32_Float;
+                case SurfaceFormat.Vector4:
+                    return SharpDX.DXGI.Format.R32G32B32A32_Float;
+                case SurfaceFormat.HalfVector4:
+                    return SharpDX.DXGI.Format.R16G16B16A16_Float;
+
+                case SurfaceFormat.HdrBlendable:
+                    // TODO: This needs to check the graphics device and 
+                    // return the best hdr blendable format for the device.
+                    return SharpDX.DXGI.Format.R16G16B16A16_Float;
+
+                case SurfaceFormat.Bgr32:
+                    return SharpDX.DXGI.Format.B8G8R8X8_UNorm;
+                case SurfaceFormat.Bgra32:
+                    return SharpDX.DXGI.Format.B8G8R8A8_UNorm;
+
+                case SurfaceFormat.ColorSRgb:
+                    return SharpDX.DXGI.Format.R8G8B8A8_UNorm_SRgb;
+                case SurfaceFormat.Bgr32SRgb:
+                    return SharpDX.DXGI.Format.B8G8R8X8_UNorm_SRgb;
+                case SurfaceFormat.Bgra32SRgb:
+                    return SharpDX.DXGI.Format.B8G8R8A8_UNorm_SRgb;
+                case SurfaceFormat.Dxt1SRgb:
+                    return SharpDX.DXGI.Format.BC1_UNorm_SRgb;
+                case SurfaceFormat.Dxt3SRgb:
+                    return SharpDX.DXGI.Format.BC2_UNorm_SRgb;
+                case SurfaceFormat.Dxt5SRgb:
+                    return SharpDX.DXGI.Format.BC3_UNorm_SRgb;
+            }
+        }
+
+		static public RawVector2 ToVector2(this Vector2 vec)
+        {
+            return new RawVector2(vec.X, vec.Y);
+        }
+
+        static public RawVector3 ToVector3(this Vector3 vec)
+        {
+            return new RawVector3(vec.X, vec.Y, vec.Z);
+        }
+
+        static public RawVector4 ToVector4(this Vector4 vec)
+        {
+            return new RawVector4(vec.X, vec.Y, vec.Z, vec.W);
+        }
+
+        static public RawColor4 ToColor4(this Color color)
+        {
+            return new RawColor4(color.R / 255.0f, color.G / 255.0f, color.B / 255.0f, color.A / 255.0f);
+        }
+
+        static public SharpDX.Direct3D11.Comparison ToComparison(this CompareFunction compare)
+        {
+            switch (compare)
+            {
+                case CompareFunction.Always:
+                    return SharpDX.Direct3D11.Comparison.Always;
+
+                case CompareFunction.Equal:
+                    return SharpDX.Direct3D11.Comparison.Equal;
+
+                case CompareFunction.Greater:
+                    return SharpDX.Direct3D11.Comparison.Greater;
+
+                case CompareFunction.GreaterEqual:
+                    return SharpDX.Direct3D11.Comparison.GreaterEqual;
+
+                case CompareFunction.Less:
+                    return SharpDX.Direct3D11.Comparison.Less;
+
+                case CompareFunction.LessEqual:
+                    return SharpDX.Direct3D11.Comparison.LessEqual;
+
+                case CompareFunction.Never:
+                    return SharpDX.Direct3D11.Comparison.Never;
+
+                case CompareFunction.NotEqual:
+                    return SharpDX.Direct3D11.Comparison.NotEqual;
+
+                default:
+                    throw new ArgumentException("Invalid comparison!");
+            }
+        }
+    }
+}
diff --git a/MonoGame.Framework/Windows/WinFormsGameForm.cs b/MonoGame.Framework/Windows/WinFormsGameForm.cs
new file mode 100644
index 00000000000..13effe7a990
--- /dev/null
+++ b/MonoGame.Framework/Windows/WinFormsGameForm.cs
@@ -0,0 +1,165 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Windows.Forms;
+using Microsoft.Xna.Framework.Input.Touch;
+using MonoGame.Framework;
+
+
+namespace Microsoft.Xna.Framework.Windows
+{
+    internal static class MessageExtensions
+    {     
+        public static int GetPointerId(this Message msg)
+        {
+            return (short)msg.WParam;
+        }
+
+        public static System.Drawing.Point GetPointerLocation(this Message msg)
+        {
+            var lowword = msg.LParam.ToInt32();
+
+            return new System.Drawing.Point()
+                       {
+                           X = (short)(lowword),
+                           Y = (short)(lowword >> 16),
+                       };
+        }
+    }
+
+    [System.ComponentModel.DesignerCategory("Code")]
+    internal class WinFormsGameForm : Form
+    {
+        private readonly WinFormsGameWindow _window;
+
+        public const int WM_MOUSEHWHEEL = 0x020E;
+        public const int WM_POINTERUP = 0x0247;
+        public const int WM_POINTERDOWN = 0x0246;
+        public const int WM_POINTERUPDATE = 0x0245;
+        public const int WM_KEYDOWN = 0x0100;
+        public const int WM_TABLET_QUERYSYSTEMGESTURESTA = (0x02C0 + 12);
+
+        public const int WM_ENTERSIZEMOVE = 0x0231;
+        public const int WM_EXITSIZEMOVE = 0x0232;
+
+        public const int WM_SYSCOMMAND = 0x0112;
+
+        public bool AllowAltF4 = true;
+
+        internal bool IsResizing { get; set; }
+
+        #region Events
+
+        public event EventHandler<HorizontalMouseWheelEventArgs> MouseHorizontalWheel;
+
+        #endregion
+
+        public WinFormsGameForm(WinFormsGameWindow window)
+        {
+            _window = window;
+        }
+
+        public void CenterOnPrimaryMonitor()
+        {
+             Location = new System.Drawing.Point(
+                 (Screen.PrimaryScreen.WorkingArea.Width  - Width ) / 2,
+                 (Screen.PrimaryScreen.WorkingArea.Height - Height) / 2);
+        }
+
+        [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")]
+        protected override void WndProc(ref Message m)
+        {
+            var state = TouchLocationState.Invalid;
+
+            switch (m.Msg)
+            {
+                case WM_TABLET_QUERYSYSTEMGESTURESTA:
+                    {
+                        // This disables the windows touch helpers, popups, and 
+                        // guides that get in the way of touch gameplay.
+                        const int flags = 0x00000001 | // TABLET_DISABLE_PRESSANDHOLD
+                                          0x00000008 | // TABLET_DISABLE_PENTAPFEEDBACK
+                                          0x00000010 | // TABLET_DISABLE_PENBARRELFEEDBACK
+                                          0x00000100 | // TABLET_DISABLE_TOUCHUIFORCEON
+                                          0x00000200 | // TABLET_DISABLE_TOUCHUIFORCEOFF
+                                          0x00008000 | // TABLET_DISABLE_TOUCHSWITCH
+                                          0x00010000 | // TABLET_DISABLE_FLICKS
+                                          0x00080000 | // TABLET_DISABLE_SMOOTHSCROLLING 
+                                          0x00100000; // TABLET_DISABLE_FLICKFALLBACKKEYS
+                        m.Result = new IntPtr(flags);
+                        return;
+                    }
+#if (WINDOWS && DIRECTX)
+                case WM_KEYDOWN:
+                    switch (m.WParam.ToInt32())
+                    {
+                        case 0x5B:  // Left Windows Key
+                        case 0x5C: // Right Windows Key
+
+                            if (_window.IsFullScreen && _window.HardwareModeSwitch)
+                                this.WindowState = FormWindowState.Minimized;
+ 		 
+                            break;
+                    }
+                    break;
+#endif
+                case WM_SYSCOMMAND:
+
+                    var wParam = m.WParam.ToInt32();
+
+                    if (!AllowAltF4 && wParam == 0xF060 && m.LParam.ToInt32() == 0 && Focused)
+                    {
+                        m.Result = IntPtr.Zero;
+                        return;
+                    }
+
+                    // Disable the system menu from being toggled by
+                    // keyboard input so we can own the ALT key.
+                    if (wParam == 0xF100) // SC_KEYMENU
+                    {
+                        m.Result = IntPtr.Zero;
+                        return;
+                    }
+                    break;
+
+                case WM_POINTERUP:
+                    state = TouchLocationState.Released;
+                    break;
+                case WM_POINTERDOWN:
+                    state = TouchLocationState.Pressed;
+                    break;
+                case WM_POINTERUPDATE:
+                    state = TouchLocationState.Moved;
+                    break;
+                case WM_MOUSEHWHEEL:
+                    var delta = (short)(((ulong)m.WParam >> 16) & 0xffff); ;
+                    var handler = MouseHorizontalWheel;
+
+                    if (handler != null)
+                        handler(this, new HorizontalMouseWheelEventArgs(delta));
+                    break;
+                case WM_ENTERSIZEMOVE:
+                    IsResizing = true;
+                    break;
+                case WM_EXITSIZEMOVE:
+                    IsResizing = false;
+                    break;
+            }
+
+            if (state != TouchLocationState.Invalid)
+            {
+                var id = m.GetPointerId();
+
+                var position = m.GetPointerLocation();
+                position = PointToClient(position);
+                var vec = new Vector2(position.X, position.Y);
+
+                _window.TouchPanelState.AddEvent(id, state, vec, false);
+            }
+
+            base.WndProc(ref m);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Windows/WinFormsGamePlatform.cs b/MonoGame.Framework/Windows/WinFormsGamePlatform.cs
new file mode 100644
index 00000000000..8565fbd40d2
--- /dev/null
+++ b/MonoGame.Framework/Windows/WinFormsGamePlatform.cs
@@ -0,0 +1,138 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using Microsoft.Xna.Framework;
+using System.Windows.Forms;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+
+namespace MonoGame.Framework
+{
+    class WinFormsGamePlatform : GamePlatform
+    {
+        //internal static string LaunchParameters;
+
+        private WinFormsGameWindow _window;
+
+        public WinFormsGamePlatform(Game game)
+            : base(game)
+        {
+            _window = new WinFormsGameWindow(this);
+
+            Window = _window;
+        }
+
+        public override GameRunBehavior DefaultRunBehavior
+        {
+            get { return GameRunBehavior.Synchronous; }
+        }
+
+        protected override void OnIsMouseVisibleChanged()
+        {
+            _window.MouseVisibleToggled();
+        }
+
+        public override bool BeforeRun()
+        {
+            _window.UpdateWindows();
+            return base.BeforeRun();
+        }
+
+        public override void BeforeInitialize()
+        {
+            base.BeforeInitialize();
+
+            var gdm = Game.graphicsDeviceManager;
+            if (gdm == null)
+            {
+                _window.Initialize(GraphicsDeviceManager.DefaultBackBufferWidth, GraphicsDeviceManager.DefaultBackBufferHeight);
+            }
+            else
+            {
+                var pp = Game.GraphicsDevice.PresentationParameters;
+                _window.Initialize(pp);
+            }
+        }
+
+        public override void RunLoop()
+        {
+            _window.RunLoop();
+        }
+
+        public override void StartRunLoop()
+        {
+            throw new NotSupportedException("The Windows platform does not support asynchronous run loops");
+        }
+        
+        public override void Exit()
+        {
+            if (_window != null)
+                _window.Dispose();
+            _window = null;
+            Window = null;
+        }
+
+        public override bool BeforeUpdate(GameTime gameTime)
+        {
+            return true;
+        }
+
+        public override bool BeforeDraw(GameTime gameTime)
+        {
+            return true;
+        }
+
+        public override void EnterFullScreen()
+        {
+        }
+
+        public override void ExitFullScreen()
+        {
+        }
+
+        internal override void OnPresentationChanged(PresentationParameters pp)
+        {
+            _window.OnPresentationChanged(pp);
+        }
+
+        public override void EndScreenDeviceChange(string screenDeviceName, int clientWidth, int clientHeight)
+        {
+        }
+
+        public override void BeginScreenDeviceChange(bool willBeFullScreen)
+        {
+        }
+
+        public override void Log(string message)
+        {
+            Debug.WriteLine(message);
+        }
+
+        public override void Present()
+        {
+            var device = Game.GraphicsDevice;
+            if ( device != null )
+                device.Present();
+        }
+		
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (_window != null)
+                {
+                    _window.Dispose();
+                    _window = null;
+                    Window = null;
+                }
+                Microsoft.Xna.Framework.Media.MediaManagerState.CheckShutdown();
+            }
+
+            base.Dispose(disposing);
+        }
+    }
+}
diff --git a/MonoGame.Framework/Windows/WinFormsGameWindow.cs b/MonoGame.Framework/Windows/WinFormsGameWindow.cs
new file mode 100644
index 00000000000..6a605af9e90
--- /dev/null
+++ b/MonoGame.Framework/Windows/WinFormsGameWindow.cs
@@ -0,0 +1,684 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Windows.Forms;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using Microsoft.Xna.Framework.Input.Touch;
+using Microsoft.Xna.Framework.Windows;
+using ButtonState = Microsoft.Xna.Framework.Input.ButtonState;
+using Keys = Microsoft.Xna.Framework.Input.Keys;
+using Point = System.Drawing.Point;
+using Rectangle = Microsoft.Xna.Framework.Rectangle;
+using XnaPoint = Microsoft.Xna.Framework.Point;
+
+namespace MonoGame.Framework
+{
+    class WinFormsGameWindow : GameWindow, IDisposable
+    {
+        internal WinFormsGameForm Form;
+
+        static private ReaderWriterLockSlim _allWindowsReaderWriterLockSlim = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
+        static private List<WinFormsGameWindow> _allWindows = new List<WinFormsGameWindow>();
+
+        private WinFormsGamePlatform _platform;
+
+        private bool _isResizable;
+        private bool _isBorderless;
+        private bool _isMouseHidden;
+        private bool _isMouseInBounds;
+
+        private Point _locationBeforeFullScreen;
+        // flag to indicate that we're switching to/from full screen and should ignore resize events
+        private bool _switchingFullScreen;
+
+        // true if window position was moved either through code or by dragging/resizing the form
+        private bool _wasMoved;
+
+        private bool _isResizeTickEnabled;
+        private readonly System.Timers.Timer _resizeTickTimer;
+
+        #region Internal Properties
+
+        internal Game Game { get; private set; }
+
+        #endregion
+
+        #region Public Properties
+
+        public override IntPtr Handle { get { return Form.Handle; } }
+
+        public override string ScreenDeviceName { get { return String.Empty; } }
+
+        public override Rectangle ClientBounds
+        {
+            get
+            {
+                var position = Form.PointToScreen(Point.Empty);
+                var size = Form.ClientSize;
+                return new Rectangle(position.X, position.Y, size.Width, size.Height);
+            }
+        }
+
+        public override bool AllowUserResizing
+        {
+            get { return _isResizable; }
+            set
+            {
+                if (_isResizable != value)
+                {
+                    _isResizable = value;
+                    Form.MaximizeBox = _isResizable;
+                }
+                else
+                    return;
+                if (_isBorderless)
+                    return;
+                Form.FormBorderStyle = _isResizable ? FormBorderStyle.Sizable : FormBorderStyle.FixedSingle;
+            }
+        }
+
+        public override bool AllowAltF4
+        {
+             get { return base.AllowAltF4; }
+             set
+             {
+                 Form.AllowAltF4 = value;
+                 base.AllowAltF4 = value;
+             }
+        }
+
+        public override DisplayOrientation CurrentOrientation
+        {
+            get { return DisplayOrientation.Default; }
+        }
+
+        public override XnaPoint Position
+        {
+            get { return new XnaPoint(Form.Location.X, Form.Location.Y); }
+            set
+            {
+                _wasMoved = true;
+                Form.Location = new Point(value.X, value.Y);
+                RefreshAdapter();
+            }
+        }
+
+        protected internal override void SetSupportedOrientations(DisplayOrientation orientations)
+        {
+        }
+
+        public override bool IsBorderless
+        {
+            get { return _isBorderless; }
+            set
+            {
+                if (_isBorderless != value)
+                    _isBorderless = value;
+                else
+                    return;
+                if (_isBorderless)
+                    Form.FormBorderStyle = FormBorderStyle.None;
+                else
+                    Form.FormBorderStyle = _isResizable ? FormBorderStyle.Sizable : FormBorderStyle.FixedSingle;
+            }
+        }
+
+        public bool IsFullScreen { get; private set; }
+        public bool HardwareModeSwitch { get; private set; }
+
+        #endregion
+
+        internal WinFormsGameWindow(WinFormsGamePlatform platform)
+        {
+            _platform = platform;
+            Game = platform.Game;
+
+            Form = new WinFormsGameForm(this);
+            ChangeClientSize(new Size(GraphicsDeviceManager.DefaultBackBufferWidth, GraphicsDeviceManager.DefaultBackBufferHeight));
+
+            SetIcon();
+            Title = Utilities.AssemblyHelper.GetDefaultWindowTitle();
+
+            Form.MaximizeBox = false;
+            Form.FormBorderStyle = FormBorderStyle.FixedSingle;
+            Form.StartPosition = FormStartPosition.Manual;
+
+            // Capture mouse events.
+            Mouse.WindowHandle = Form.Handle;
+            Form.MouseWheel += OnMouseScroll;
+            Form.MouseHorizontalWheel += OnMouseHorizontalScroll;
+            Form.MouseEnter += OnMouseEnter;
+            Form.MouseLeave += OnMouseLeave;            
+
+            _resizeTickTimer = new System.Timers.Timer(1) { SynchronizingObject = Form, AutoReset = false };
+            _resizeTickTimer.Elapsed += OnResizeTick;
+
+            Form.Activated += OnActivated;
+            Form.Deactivate += OnDeactivate;
+            Form.Resize += OnResize;
+            Form.ResizeBegin += OnResizeBegin;
+            Form.ResizeEnd += OnResizeEnd;
+
+            Form.KeyPress += OnKeyPress;
+
+            RegisterToAllWindows();
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct POINTSTRUCT
+        {
+            public int X;
+            public int Y;
+        }
+
+        [DllImport("shell32.dll", CharSet = CharSet.Auto, BestFitMapping = false)]
+        private static extern IntPtr ExtractIcon(IntPtr hInst, string exeFileName, int iconIndex);
+        
+        [DllImport("user32.dll", ExactSpelling=true, CharSet=CharSet.Auto)]
+        [return: MarshalAsAttribute(System.Runtime.InteropServices.UnmanagedType.Bool)]
+        internal static extern bool GetCursorPos(out POINTSTRUCT pt);
+        
+        [DllImport("user32.dll", ExactSpelling=true, CharSet=CharSet.Auto)]
+        internal static extern int MapWindowPoints(HandleRef hWndFrom, HandleRef hWndTo, out POINTSTRUCT pt, int cPoints);
+
+        private void SetIcon()
+        {
+            // When running unit tests this can return null.
+            var assembly = Assembly.GetEntryAssembly();
+            if (assembly == null)
+                return;
+            var handle = ExtractIcon(IntPtr.Zero, assembly.Location, 0);
+            if (handle != IntPtr.Zero)
+                Form.Icon = Icon.FromHandle(handle);
+        }
+
+        ~WinFormsGameWindow()
+        {
+            Dispose(false);
+        }
+
+        private void RegisterToAllWindows()
+        {
+            _allWindowsReaderWriterLockSlim.EnterWriteLock();
+
+            try
+            {
+                _allWindows.Add(this);
+            }
+            finally
+            {
+                _allWindowsReaderWriterLockSlim.ExitWriteLock();
+            }
+        }
+
+        private void UnregisterFromAllWindows()
+        {
+            _allWindowsReaderWriterLockSlim.EnterWriteLock();
+
+            try
+            {
+                _allWindows.Remove(this);
+            }
+            finally
+            {
+                _allWindowsReaderWriterLockSlim.ExitWriteLock();
+            }
+        }
+
+        private void OnActivated(object sender, EventArgs eventArgs)
+        {
+            _platform.IsActive = true;
+            Keyboard.SetActive(true);
+        }
+
+        private void OnDeactivate(object sender, EventArgs eventArgs)
+        {
+            // If in exclusive mode full-screen, force it out of exclusive mode and minimize the window
+			if( IsFullScreen && _platform.Game.GraphicsDevice.PresentationParameters.HardwareModeSwitch ) {			
+				// This is true when the user presses the Windows key while game window has focus
+				if( Form.WindowState == FormWindowState.Minimized )
+					MinimizeFullScreen();				
+			}
+            _platform.IsActive = false;
+            Keyboard.SetActive(false);
+        }
+
+        private void OnMouseScroll(object sender, MouseEventArgs mouseEventArgs)
+        {
+            MouseState.ScrollWheelValue += mouseEventArgs.Delta;
+        }
+
+        private void OnMouseHorizontalScroll(object sender, HorizontalMouseWheelEventArgs mouseEventArgs)
+        {
+            MouseState.HorizontalScrollWheelValue += mouseEventArgs.Delta;
+        }
+
+        private void UpdateMouseState()
+        {
+            // If we call the form client functions before the form has
+            // been made visible it will cause the wrong window size to
+            // be applied at startup.
+            if (!Form.Visible)
+                return;
+
+            POINTSTRUCT pos;
+            GetCursorPos(out pos);
+            MapWindowPoints(new HandleRef(null, IntPtr.Zero), new HandleRef(Form, Form.Handle), out pos, 1);
+            var clientPos = new System.Drawing.Point(pos.X, pos.Y);
+            var withinClient = Form.ClientRectangle.Contains(clientPos);
+            var buttons = Control.MouseButtons;
+
+            var previousState = MouseState.LeftButton;
+
+            MouseState.X = clientPos.X;
+            MouseState.Y = clientPos.Y;
+            MouseState.LeftButton = (buttons & MouseButtons.Left) == MouseButtons.Left ? ButtonState.Pressed : ButtonState.Released;
+            MouseState.MiddleButton = (buttons & MouseButtons.Middle) == MouseButtons.Middle ? ButtonState.Pressed : ButtonState.Released;
+            MouseState.RightButton = (buttons & MouseButtons.Right) == MouseButtons.Right ? ButtonState.Pressed : ButtonState.Released;
+            MouseState.XButton1 = (buttons & MouseButtons.XButton1) == MouseButtons.XButton1 ? ButtonState.Pressed : ButtonState.Released;
+            MouseState.XButton2 = (buttons & MouseButtons.XButton2) == MouseButtons.XButton2 ? ButtonState.Pressed : ButtonState.Released;
+
+            // Don't process touch state if we're not active 
+            // and the mouse is within the client area.
+            if (!_platform.IsActive || !withinClient)
+            {                
+                if (MouseState.LeftButton == ButtonState.Pressed)
+                {
+                    // Release mouse TouchLocation
+                    var touchX = MathHelper.Clamp(MouseState.X, 0, Form.ClientRectangle.Width-1);
+                    var touchY = MathHelper.Clamp(MouseState.Y, 0, Form.ClientRectangle.Height-1);
+                    TouchPanelState.AddEvent(0, TouchLocationState.Released, new Vector2(touchX, touchY), true);
+                }
+                return;
+            }
+            
+            TouchLocationState? touchState = null;
+            if (MouseState.LeftButton == ButtonState.Pressed)
+                if (previousState == ButtonState.Released)
+                    touchState = TouchLocationState.Pressed;
+                else
+                    touchState = TouchLocationState.Moved;
+            else if (previousState == ButtonState.Pressed)
+                touchState = TouchLocationState.Released;
+
+            if (touchState.HasValue)
+                TouchPanelState.AddEvent(0, touchState.Value, new Vector2(MouseState.X, MouseState.Y), true);
+        } 
+
+        private void OnMouseEnter(object sender, EventArgs e)
+        {
+            _isMouseInBounds = true;
+            if (!_platform.IsMouseVisible && !_isMouseHidden)
+            {
+                _isMouseHidden = true;
+                Cursor.Hide();
+            }
+        }
+
+        private void OnMouseLeave(object sender, EventArgs e)
+        {
+            _isMouseInBounds = false;
+            if (_isMouseHidden)
+            {
+                _isMouseHidden = false;
+                Cursor.Show();
+            }
+        }
+
+        [DllImport("user32.dll")]
+        private static extern short VkKeyScanEx(char ch, IntPtr dwhkl);
+
+        private void OnKeyPress(object sender, KeyPressEventArgs e)
+        {
+            var key = (Keys) (VkKeyScanEx(e.KeyChar, InputLanguage.CurrentInputLanguage.Handle) & 0xff);
+            OnTextInput(sender, new TextInputEventArgs(e.KeyChar, key));
+        }
+
+        internal void Initialize(int width, int height)
+        {
+            ChangeClientSize(new Size(width, height));
+        }
+
+        internal void Initialize(PresentationParameters pp)
+        {
+            ChangeClientSize(new Size(pp.BackBufferWidth, pp.BackBufferHeight));
+
+            if (pp.IsFullScreen)
+            {
+                EnterFullScreen(pp);
+                if (!pp.HardwareModeSwitch)
+                    _platform.Game.GraphicsDevice.OnPresentationChanged();
+            }
+        }
+
+        private FormWindowState _lastFormState;
+
+        private void OnResize(object sender, EventArgs eventArgs)
+        {
+            if (_switchingFullScreen || Form.IsResizing)
+                return;
+
+            // this event can be triggered when moving the window through Windows hotkeys
+            // in that case we should no longer center the window after resize
+            if (_lastFormState == Form.WindowState)
+                _wasMoved = true;
+
+            if (Game.Window == this && Form.WindowState != FormWindowState.Minimized) {
+                // we may need to restore full screen when coming back from a minimized window
+                if (_lastFormState == FormWindowState.Minimized)
+                    _platform.Game.GraphicsDevice.SetHardwareFullscreen();
+                UpdateBackBufferSize();
+            }
+
+            _lastFormState = Form.WindowState;
+            OnClientSizeChanged();
+        }
+
+        private void OnResizeBegin(object sender, EventArgs e)
+        {
+            _isResizeTickEnabled = true;
+            _resizeTickTimer.Enabled = true;
+        }
+
+        private void OnResizeTick(object sender, System.Timers.ElapsedEventArgs e)
+        {
+            if (!_isResizeTickEnabled)
+                return;
+            UpdateWindows();
+            Game.Tick();
+            _resizeTickTimer.Enabled = true;
+        }
+
+        private void OnResizeEnd(object sender, EventArgs eventArgs)
+        {
+            _isResizeTickEnabled = false;
+            _resizeTickTimer.Enabled = false;
+
+            _wasMoved = true;
+            if (Game.Window == this)
+            {
+                UpdateBackBufferSize();
+                RefreshAdapter();
+            }
+
+            OnClientSizeChanged();
+        }
+
+        private void RefreshAdapter()
+        {
+            // the display that the window is on might have changed, so we need to
+            // check and possibly update the Adapter of the GraphicsDevice
+            if (Game.GraphicsDevice != null)
+                Game.GraphicsDevice.RefreshAdapter();
+        }
+
+        private void UpdateBackBufferSize()
+        {
+            var manager = Game.graphicsDeviceManager;
+            if (manager.GraphicsDevice == null)
+                return;
+
+            var newSize = Form.ClientSize;
+            if (newSize.Width == manager.PreferredBackBufferWidth
+                && newSize.Height == manager.PreferredBackBufferHeight)
+                return;
+
+            // Set the default new back buffer size
+            manager.PreferredBackBufferWidth = newSize.Width;
+            manager.PreferredBackBufferHeight = newSize.Height;
+            manager.ApplyChanges();
+        }
+
+        protected override void SetTitle(string title)
+        {
+            Form.Text = title;
+        }
+
+        internal void RunLoop()
+        {
+            Application.Idle += TickOnIdle;
+            Application.Run(Form);
+            Application.Idle -= TickOnIdle;
+
+            // We need to remove the WM_QUIT message in the message 
+            // pump as it will keep us from restarting on this 
+            // same thread.
+            //
+            // This is critical for some NUnit runners which
+            // typically will run all the tests on the same
+            // process/thread.
+            var msg = new NativeMessage();
+            do
+            {
+                if (msg.msg == WM_QUIT)
+                    break;
+
+                Thread.Sleep(100);
+            } 
+            while (PeekMessage(out msg, IntPtr.Zero, 0, 1 << 5, 1));
+        }
+
+        // Run game loop when the app becomes Idle.
+        private void TickOnIdle(object sender, EventArgs e)
+        {
+            var nativeMsg = new NativeMessage();
+            do
+            {
+                UpdateWindows();
+                Game.Tick();
+            }
+            while (!PeekMessage(out nativeMsg, IntPtr.Zero, 0, 0, 0) && Form != null && Form.IsDisposed == false);
+        }
+
+        internal void UpdateWindows()
+        {
+            _allWindowsReaderWriterLockSlim.EnterReadLock();
+
+            try
+            {
+                // Update the mouse state for each window.
+                foreach (var window in _allWindows)
+                    if (window.Game == Game)
+                        window.UpdateMouseState();
+            }
+            finally
+            {
+                _allWindowsReaderWriterLockSlim.ExitReadLock();
+            }
+        }
+
+        private const uint WM_QUIT = 0x12;
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct NativeMessage
+        {
+            public IntPtr handle;
+            public uint msg;
+            public IntPtr wParam;
+            public IntPtr lParam;
+            public uint time;
+            public System.Drawing.Point p;
+        }
+
+        internal void ChangeClientSize(Size clientBounds)
+        {
+            var prevIsResizing = Form.IsResizing;
+            // make sure we don't see the events from this as a user resize
+            Form.IsResizing = true;
+
+            if(this.Form.ClientSize != clientBounds)
+                this.Form.ClientSize = clientBounds;
+
+            // if the window wasn't moved manually and it's resized, it should be centered
+            if (!_wasMoved)
+                Form.CenterOnPrimaryMonitor();
+
+            Form.IsResizing = prevIsResizing;
+        }
+
+        [System.Security.SuppressUnmanagedCodeSecurity] // We won't use this maliciously
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        private static extern bool PeekMessage(out NativeMessage msg, IntPtr hWnd, uint messageFilterMin, uint messageFilterMax, uint flags);
+
+        #region Public Methods
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (Form != null)
+                {
+                    UnregisterFromAllWindows(); 
+                    Form.Dispose();
+                    Form = null;
+                }
+            }
+            _platform = null;
+            Game = null;
+            Mouse.WindowHandle = IntPtr.Zero;
+        }
+
+        public override void BeginScreenDeviceChange(bool willBeFullScreen)
+        {
+        }
+
+        public override void EndScreenDeviceChange(string screenDeviceName, int clientWidth, int clientHeight)
+        {
+        }
+
+        public void MouseVisibleToggled()
+        {
+            if (_platform.IsMouseVisible)
+            {
+                if (_isMouseHidden)
+                {
+                    Cursor.Show();
+                    _isMouseHidden = false;
+                }
+            }
+            else if (!_isMouseHidden && _isMouseInBounds)
+            {
+                Cursor.Hide();
+                _isMouseHidden = true;
+            }
+        }
+
+        internal void OnPresentationChanged(PresentationParameters pp)
+        {
+            var raiseClientSizeChanged = false;
+            if (pp.IsFullScreen && pp.HardwareModeSwitch && IsFullScreen && HardwareModeSwitch)
+            {
+                if( _platform.IsActive ) {
+					// stay in hardware full screen, need to call ResizeTargets so the displaymode can be switched
+					_platform.Game.GraphicsDevice.ResizeTargets();
+				} else {
+					// This needs to be called in case the user presses the Windows key while the focus is on the second monitor,
+					//	which (sometimes) causes the window to exit fullscreen mode, but still keeps it visible
+					MinimizeFullScreen();
+				}
+            }
+            else if (pp.IsFullScreen && (!IsFullScreen || pp.HardwareModeSwitch != HardwareModeSwitch))
+            {
+                EnterFullScreen(pp);
+                raiseClientSizeChanged = true;
+            }
+            else if (!pp.IsFullScreen && IsFullScreen)
+            {
+                ExitFullScreen();
+                raiseClientSizeChanged = true;
+            }
+
+            ChangeClientSize(new Size(pp.BackBufferWidth, pp.BackBufferHeight));
+
+            if (raiseClientSizeChanged)
+                OnClientSizeChanged();
+        }
+
+        #endregion
+
+        private void EnterFullScreen(PresentationParameters pp)
+        {
+            _switchingFullScreen = true;
+
+            // store the location of the window so we can restore it later
+            if (!IsFullScreen)
+                _locationBeforeFullScreen = Form.Location;
+
+            _platform.Game.GraphicsDevice.SetHardwareFullscreen();
+
+            if (!pp.HardwareModeSwitch)
+            {
+                // FIXME: setting the WindowState to Maximized when the form is not shown will not update the ClientBounds
+                // this causes the back buffer to be the wrong size when initializing in soft full screen
+                // we show the form to bypass the issue
+                Form.Show();
+                IsBorderless = true;
+                Form.WindowState = FormWindowState.Maximized;
+                _lastFormState = FormWindowState.Maximized;
+            }
+
+            IsFullScreen = true;
+            HardwareModeSwitch = pp.HardwareModeSwitch;
+
+            _switchingFullScreen = false;
+        }
+
+
+        [DllImport("user32.dll")]
+        static extern bool RedrawWindow(IntPtr hWnd, IntPtr lprcUpdate, IntPtr hrgnUpdate, uint flags);
+
+        private void ExitFullScreen()
+        {
+            _switchingFullScreen = true;
+
+            _platform.Game.GraphicsDevice.ClearHardwareFullscreen();
+
+            IsBorderless = false;
+            Form.WindowState = FormWindowState.Normal;
+            _lastFormState = FormWindowState.Normal;
+            Form.Location = _locationBeforeFullScreen;
+            IsFullScreen = false;
+
+            // Windows does not always correctly redraw the desktop when exiting soft full screen, so force a redraw
+            if (!HardwareModeSwitch)
+                RedrawWindow(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, 1);
+
+            _switchingFullScreen = false;
+        }
+
+        private void MinimizeFullScreen()
+        {
+            _switchingFullScreen = true;
+
+            _platform.Game.GraphicsDevice.ClearHardwareFullscreen();
+
+            IsBorderless = false;
+            Form.WindowState = FormWindowState.Minimized;
+            _lastFormState = FormWindowState.Minimized;
+            Form.Location = _locationBeforeFullScreen;
+            IsFullScreen = false;
+
+            // Windows does not always correctly redraw the desktop when exiting soft full screen, so force a redraw
+            if (!HardwareModeSwitch)
+                RedrawWindow(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, 1);
+
+            _switchingFullScreen = false;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/WindowsUniversal/GameFrameworkViewSource.cs b/MonoGame.Framework/WindowsUniversal/GameFrameworkViewSource.cs
new file mode 100644
index 00000000000..68703ecddc5
--- /dev/null
+++ b/MonoGame.Framework/WindowsUniversal/GameFrameworkViewSource.cs
@@ -0,0 +1,29 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework;
+using Windows.ApplicationModel.Activation;
+using Windows.ApplicationModel.Core;
+
+
+namespace MonoGame.Framework
+{
+    public class GameFrameworkViewSource<T> : IFrameworkViewSource
+        where T : Game, new()
+    {
+        private Action<T, IActivatedEventArgs> _gameConstructorCustomizationDelegate = null;
+
+        public GameFrameworkViewSource(Action<T, IActivatedEventArgs> gameConstructorCustomizationDelegate = null)
+        {
+            this._gameConstructorCustomizationDelegate = gameConstructorCustomizationDelegate;
+        }
+
+        [CLSCompliant(false)]
+        public IFrameworkView CreateView()
+        {
+            return new UAPFrameworkView<T>(_gameConstructorCustomizationDelegate);
+        }
+    }
+}
diff --git a/MonoGame.Framework/WindowsUniversal/GamerServices/SignedInGamer.cs b/MonoGame.Framework/WindowsUniversal/GamerServices/SignedInGamer.cs
new file mode 100644
index 00000000000..5545ac5ce75
--- /dev/null
+++ b/MonoGame.Framework/WindowsUniversal/GamerServices/SignedInGamer.cs
@@ -0,0 +1,331 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+accept the license, do not use the software.
+
+1. Definitions
+The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the software.
+A "contributor" is any person that distributes its contribution under this license.
+"Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+2. Grant of Rights
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+
+3. Conditions and Limitations
+(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+your patent license from such contributor to the software ends automatically.
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+notices that are present in the software.
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+code form, you may only do so under a license that complies with this license.
+(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+purpose and non-infringement.
+*/
+#endregion License
+
+#region Statement
+using System;
+
+#endregion Statement
+
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    public class SignedInGamer : Gamer
+    {
+		// TODO private GKLocalPlayer lp;
+		
+		private AchievementCollection gamerAchievements;
+		private FriendCollection friendCollection;
+		private bool isSignedInToLive = true;
+		
+		delegate void AuthenticationDelegate();
+		
+		public IAsyncResult BeginAuthentication(AsyncCallback callback, Object asyncState)
+		{
+			// Go off authenticate
+			AuthenticationDelegate ad = DoAuthentication; 
+			
+			return ad.BeginInvoke(callback, ad);
+		}
+		
+		public void EndAuthentication( IAsyncResult result )
+		{
+			AuthenticationDelegate ad = (AuthenticationDelegate)result.AsyncState; 
+			
+			ad.EndInvoke(result);
+		}
+		
+		private void DoAuthentication()
+		{
+		}
+		
+		public SignedInGamer()
+		{		
+			var result = BeginAuthentication(null, null);	
+			EndAuthentication( result );
+		}
+		
+		private void AuthenticationCompletedCallback( IAsyncResult result )
+		{
+			EndAuthentication(result);	
+		}
+		
+		#region Methods
+		public FriendCollection GetFriends()
+		{
+			if(IsSignedInToLive)
+			{
+				if ( friendCollection == null )
+				{
+					friendCollection = new FriendCollection();
+				}
+			}
+			
+			return friendCollection;
+		}
+		
+		public bool IsFriend (Gamer gamer)
+		{
+			if ( gamer == null ) 
+				throw new ArgumentNullException();
+			
+			if ( gamer.IsDisposed )
+				throw new ObjectDisposedException(gamer.ToString());	
+			
+			bool found = false;
+			foreach(FriendGamer f in friendCollection)
+			{
+				if ( f.Gamertag == gamer.Gamertag )
+				{
+					found = true;
+				}
+			}
+			return found;
+						
+		}
+		
+		delegate AchievementCollection GetAchievementsDelegate();
+		
+		public IAsyncResult BeginGetAchievements( AsyncCallback callback, Object asyncState)
+		{
+			// Go off and grab achievements
+			GetAchievementsDelegate gad = GetAchievements; 
+			
+			return gad.BeginInvoke(callback, gad);
+		}
+		
+		private void GetAchievementCompletedCallback( IAsyncResult result )
+		{
+			// get the delegate that was used to call that method
+			GetAchievementsDelegate gad = (GetAchievementsDelegate)result.AsyncState; 
+
+			// get the return value from that method call
+			gamerAchievements = gad.EndInvoke(result);
+		}
+		
+		public AchievementCollection EndGetAchievements( IAsyncResult result )
+		{
+			GetAchievementsDelegate gad = (GetAchievementsDelegate)result.AsyncState; 
+			
+			gamerAchievements = gad.EndInvoke(result);
+			
+			return gamerAchievements;
+		}
+		
+		public AchievementCollection GetAchievements()
+		{
+			if ( IsSignedInToLive )
+			{
+				if (gamerAchievements == null)
+				{
+					gamerAchievements = new AchievementCollection();
+				}				
+			}
+			return gamerAchievements;
+		}
+		
+		delegate void AwardAchievementDelegate(string achievementId, double percentageComplete);
+
+        public IAsyncResult BeginAwardAchievement(string achievementId, AsyncCallback callback, Object state)
+        {
+            return BeginAwardAchievement(achievementId, 100.0, callback, state);
+        }
+
+		public IAsyncResult BeginAwardAchievement(
+         string achievementId,
+		 double percentageComplete,
+         AsyncCallback callback,
+         Object state
+		)
+		{	
+			// Go off and award the achievement
+			AwardAchievementDelegate aad = DoAwardAchievement; 
+				
+			return aad.BeginInvoke(achievementId, percentageComplete, callback, aad);
+		}
+		
+		public void EndAwardAchievement(IAsyncResult result)
+		{
+			AwardAchievementDelegate aad = (AwardAchievementDelegate)result.AsyncState; 
+			
+			aad.EndInvoke(result);
+		}
+		
+		private void AwardAchievementCompletedCallback( IAsyncResult result )
+		{
+			EndAwardAchievement(result);	
+		}
+		
+		public void AwardAchievement( string achievementId )
+		{			
+			AwardAchievement(achievementId, 100.0f);
+		}
+		
+		public void DoAwardAchievement( string achievementId, double percentageComplete )
+		{
+			
+		}
+		
+		public void AwardAchievement( string achievementId, double percentageComplete )
+		{
+			if (IsSignedInToLive)
+			{
+				BeginAwardAchievement( achievementId, percentageComplete, AwardAchievementCompletedCallback, null );
+			}
+		}
+		
+		public void UpdateScore( string aCategory, long aScore )
+		{
+			if (IsSignedInToLive)
+			{
+				
+			}
+		}
+		
+		public void ResetAchievements()
+		{
+			if (IsSignedInToLive)
+			{
+				
+			}
+		}
+
+		#endregion
+			
+		#region Properties
+		public GameDefaults GameDefaults 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+		
+		public bool IsGuest 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+		
+		public bool IsSignedInToLive 
+		{ 
+			get
+			{
+				return isSignedInToLive;
+			}
+			internal set{
+				isSignedInToLive = value;
+			}
+		}
+		
+		public int PartySize 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+			set
+			{
+				throw new NotSupportedException();
+			}
+		}
+		
+        public PlayerIndex PlayerIndex
+        {
+            get
+            {
+                return PlayerIndex.One;
+            }
+        }
+		
+		public GamerPresence Presence 
+		{ 
+			get
+			{
+				throw new NotSupportedException();
+			}
+		}
+
+        GamerPrivileges _privileges = new GamerPrivileges();
+        public GamerPrivileges Privileges
+        {
+            get
+            {
+                return _privileges;
+            }
+        }
+		#endregion
+		
+		
+		protected virtual void OnSignedIn(SignedInEventArgs e)
+		{
+            EventHelpers.Raise(this, SignedIn, e);
+		}
+		
+		protected virtual void OnSignedOut(SignedOutEventArgs e)
+		{
+            EventHelpers.Raise(this, SignedOut, e);
+		}
+
+		
+		#region Events
+		public static event EventHandler<SignedInEventArgs> SignedIn;
+		
+		public static event EventHandler<SignedOutEventArgs> SignedOut;
+		#endregion
+    }
+	
+	public class SignedInEventArgs : EventArgs
+	{
+		public SignedInEventArgs ( SignedInGamer gamer )
+		{
+			
+		}
+	}
+	
+	public class SignedOutEventArgs : EventArgs
+	{
+		public SignedOutEventArgs (SignedInGamer gamer )
+		{
+			
+		}
+	}
+}
diff --git a/MonoGame.Framework/WindowsUniversal/InputEvents.cs b/MonoGame.Framework/WindowsUniversal/InputEvents.cs
new file mode 100644
index 00000000000..7a57b758814
--- /dev/null
+++ b/MonoGame.Framework/WindowsUniversal/InputEvents.cs
@@ -0,0 +1,342 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using Microsoft.Xna.Framework.Input;
+using Microsoft.Xna.Framework.Input.Touch;
+using Windows.Devices.Input;
+using Windows.Graphics.Display;
+using Windows.System.Threading;
+using Windows.UI.Core;
+using Windows.UI.Input;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Input;
+
+namespace Microsoft.Xna.Framework
+{
+    internal class InputEvents
+    {
+        internal class KeyChar
+        {
+            public char Character;
+
+            public Keys Key;
+        }
+
+        public readonly ConcurrentQueue<KeyChar> TextQueue = new ConcurrentQueue<KeyChar>();
+        private KeyChar _lastEnqueuedKeyChar;
+
+        private readonly TouchQueue _touchQueue;
+
+        // To convert from DIPs (device independent pixels) to actual screen resolution pixels.
+        private static float _currentDipFactor;
+
+        public InputEvents(CoreWindow window, UIElement inputElement, TouchQueue touchQueue)
+        {
+            _touchQueue = touchQueue;
+
+            // The key events are always tied to the window as those will
+            // only arrive here if some other control hasn't gotten it.
+            window.KeyDown += CoreWindow_KeyDown;
+            window.KeyUp += CoreWindow_KeyUp;
+            window.CharacterReceived += Window_CharacterReceived;
+            window.VisibilityChanged += CoreWindow_VisibilityChanged;
+            window.Activated += CoreWindow_Activated;
+            window.SizeChanged += CoreWindow_SizeChanged;
+
+            DisplayInformation.GetForCurrentView().DpiChanged += InputEvents_DpiChanged;
+            _currentDipFactor = DisplayInformation.GetForCurrentView().LogicalDpi / 96.0f;
+
+            if (inputElement is SwapChainPanel || inputElement is SwapChainBackgroundPanel)
+            {
+                // Create a thread to precess input events.
+                var workItemHandler = new WorkItemHandler((action) =>
+                {
+                    var inputDevices = CoreInputDeviceTypes.Mouse | CoreInputDeviceTypes.Pen | CoreInputDeviceTypes.Touch;
+
+                    CoreIndependentInputSource coreIndependentInputSource;
+                    if (inputElement is SwapChainBackgroundPanel)
+                        coreIndependentInputSource = ((SwapChainBackgroundPanel)inputElement).CreateCoreIndependentInputSource(inputDevices);
+                    else
+                        coreIndependentInputSource = ((SwapChainPanel)inputElement).CreateCoreIndependentInputSource(inputDevices);
+
+                    coreIndependentInputSource.PointerPressed += CoreWindow_PointerPressed;
+                    coreIndependentInputSource.PointerMoved += CoreWindow_PointerMoved;
+                    coreIndependentInputSource.PointerReleased += CoreWindow_PointerReleased;
+                    coreIndependentInputSource.PointerWheelChanged += CoreWindow_PointerWheelChanged;
+
+                    coreIndependentInputSource.Dispatcher.ProcessEvents(CoreProcessEventsOption.ProcessUntilQuit);
+                });
+                var inputWorker = ThreadPool.RunAsync(workItemHandler, WorkItemPriority.High, WorkItemOptions.TimeSliced);
+            }
+
+            if (inputElement != null)
+            {
+                // If we have an input UIElement then we bind input events
+                // to it else we'll get events for overlapping XAML controls.
+                inputElement.PointerPressed += UIElement_PointerPressed;
+                inputElement.PointerReleased += UIElement_PointerReleased;
+                inputElement.PointerCanceled += UIElement_PointerReleased;
+                inputElement.PointerMoved += UIElement_PointerMoved;
+                inputElement.PointerWheelChanged += UIElement_PointerWheelChanged;
+            }
+            else
+            {
+                // If we only have a CoreWindow then use it for input events.
+                window.PointerPressed += CoreWindow_PointerPressed;
+                window.PointerReleased += CoreWindow_PointerReleased;
+                window.PointerMoved += CoreWindow_PointerMoved;
+                window.PointerWheelChanged += CoreWindow_PointerWheelChanged;
+            }
+        }
+
+        private void InputEvents_DpiChanged(DisplayInformation sender, object args)
+        {
+            _currentDipFactor = DisplayInformation.GetForCurrentView().LogicalDpi / 96.0f;
+        }
+
+        #region UIElement Events
+
+        private void UIElement_PointerPressed(object sender, PointerRoutedEventArgs args)
+        {
+            //Capture this pointer so we continue getting events even if it is dragged off us
+            ((UIElement)sender).CapturePointer(args.Pointer);
+
+            var pointerPoint = args.GetCurrentPoint(null);
+            PointerPressed(pointerPoint, sender as UIElement, args.Pointer);
+            args.Handled = true;
+        }
+
+        private void UIElement_PointerMoved(object sender, PointerRoutedEventArgs args)
+        {
+            var pointerPoint = args.GetCurrentPoint(null);
+            PointerMoved(pointerPoint);
+            args.Handled = true;
+        }
+
+        private void UIElement_PointerReleased(object sender, PointerRoutedEventArgs args)
+        {
+            ((UIElement)sender).ReleasePointerCapture(args.Pointer);
+
+            var pointerPoint = args.GetCurrentPoint(null);
+            PointerReleased(pointerPoint, sender as UIElement, args.Pointer);
+            args.Handled = true;
+        }
+
+        private void UIElement_PointerWheelChanged(object sender, PointerRoutedEventArgs args)
+        {
+            var pointerPoint = args.GetCurrentPoint(null);
+            UpdateMouse(pointerPoint);
+            args.Handled = true;
+        }
+
+        #endregion // UIElement Events
+
+        #region CoreWindow Events
+
+        private void CoreWindow_PointerPressed(object sender, PointerEventArgs args)
+        {
+            PointerPressed(args.CurrentPoint, null, null);
+            args.Handled = true;
+        }
+
+        private void CoreWindow_PointerMoved(object sender, PointerEventArgs args)
+        {
+            PointerMoved(args.CurrentPoint);
+            args.Handled = true;
+        }
+
+        private void CoreWindow_PointerReleased(object sender, PointerEventArgs args)
+        {
+            PointerReleased(args.CurrentPoint, null, null);
+            args.Handled = true;
+        }
+
+        private void CoreWindow_PointerWheelChanged(object sender, PointerEventArgs args)
+        {
+            UpdateMouse(args.CurrentPoint);
+            args.Handled = true;
+        }
+
+        #endregion // CoreWindow Events
+
+        private void PointerPressed(PointerPoint pointerPoint, UIElement target, Pointer pointer)
+        {
+            var pos = new Vector2((float)pointerPoint.Position.X, (float)pointerPoint.Position.Y) * _currentDipFactor;
+
+            var isTouch = pointerPoint.PointerDevice.PointerDeviceType == PointerDeviceType.Touch;
+
+            _touchQueue.Enqueue((int)pointerPoint.PointerId, TouchLocationState.Pressed, pos, !isTouch);
+
+            if (!isTouch)
+            {
+                // Mouse or stylus event.
+                UpdateMouse(pointerPoint);
+
+                // Capture future pointer events until a release.		
+                if (target != null)
+                    target.CapturePointer(pointer);
+            }
+        }
+
+        private void PointerMoved(PointerPoint pointerPoint)
+        {
+            var pos = new Vector2((float)pointerPoint.Position.X, (float)pointerPoint.Position.Y) * _currentDipFactor;
+
+            var isTouch = pointerPoint.PointerDevice.PointerDeviceType == PointerDeviceType.Touch;
+            var touchIsDown = pointerPoint.IsInContact;
+
+            if (touchIsDown)
+            {
+                _touchQueue.Enqueue((int)pointerPoint.PointerId, TouchLocationState.Moved, pos, !isTouch);
+            }
+
+            if (!isTouch)
+            {
+                // Mouse or stylus event.
+                UpdateMouse(pointerPoint);
+            }
+        }
+
+        private void PointerReleased(PointerPoint pointerPoint, UIElement target, Pointer pointer)
+        {
+            var pos = new Vector2((float)pointerPoint.Position.X, (float)pointerPoint.Position.Y) * _currentDipFactor;
+
+            var isTouch = pointerPoint.PointerDevice.PointerDeviceType == PointerDeviceType.Touch;
+
+            _touchQueue.Enqueue((int)pointerPoint.PointerId, TouchLocationState.Released, pos, !isTouch);
+
+            if (!isTouch)
+            {
+                // Mouse or stylus event.
+                UpdateMouse(pointerPoint);
+
+                // Release the captured pointer.
+                if (target != null)
+                    target.ReleasePointerCapture(pointer);
+            }
+        }
+
+        private static void UpdateMouse(PointerPoint point)
+        {
+            var x = (int)(point.Position.X * _currentDipFactor);
+            var y = (int)(point.Position.Y * _currentDipFactor);
+
+            var state = point.Properties;
+
+            int verticalScrollDelta = 0;
+            int horizontalScrollDelta = 0;
+
+            if (state.IsHorizontalMouseWheel)
+                horizontalScrollDelta = state.MouseWheelDelta;
+            else
+                verticalScrollDelta = state.MouseWheelDelta;
+
+            Mouse.PrimaryWindow.MouseState = new MouseState(x, y, 
+                Mouse.PrimaryWindow.MouseState.ScrollWheelValue + verticalScrollDelta,
+                state.IsLeftButtonPressed ? ButtonState.Pressed : ButtonState.Released,
+                state.IsMiddleButtonPressed ? ButtonState.Pressed : ButtonState.Released,
+                state.IsRightButtonPressed ? ButtonState.Pressed : ButtonState.Released,
+                state.IsXButton1Pressed ? ButtonState.Pressed : ButtonState.Released,
+                state.IsXButton2Pressed ? ButtonState.Pressed : ButtonState.Released,
+                Mouse.PrimaryWindow.MouseState.HorizontalScrollWheelValue + horizontalScrollDelta);
+        }
+
+        public void UpdateState()
+        {
+            // Update the keyboard state.
+            Keyboard.UpdateState();
+        }
+
+        private static Keys KeyTranslate(Windows.System.VirtualKey inkey, CorePhysicalKeyStatus keyStatus)
+        {
+            switch (inkey)
+            {
+                // WinRT does not distinguish between left/right keys
+                // We have to check for special keys such as control/shift/alt/ etc
+                case Windows.System.VirtualKey.Control:
+                    // we can detect right Control by checking the IsExtendedKey value.
+                    return (keyStatus.IsExtendedKey) ? Keys.RightControl : Keys.LeftControl;
+                case Windows.System.VirtualKey.Shift:
+                    // we can detect right shift by checking the scancode value.
+                    // left shift is 0x2A, right shift is 0x36. IsExtendedKey is always false.
+                    return (keyStatus.ScanCode == 0x36) ? Keys.RightShift : Keys.LeftShift;
+                // Note that the Alt key is now refered to as Menu.
+                // ALT key doesn't get fired by KeyUp/KeyDown events.
+                // One solution could be to check CoreWindow.GetKeyState(...) on every tick.
+                case Windows.System.VirtualKey.Menu:
+                    return Keys.LeftAlt;
+
+                default:
+                    return (Keys)inkey;
+            }
+        }
+
+        private void CoreWindow_KeyUp(object sender, KeyEventArgs args)
+        {
+            var xnaKey = KeyTranslate(args.VirtualKey, args.KeyStatus);
+
+            Keyboard.ClearKey(xnaKey);
+        }
+
+        private void CoreWindow_KeyDown(object sender, KeyEventArgs args)
+        {
+            var xnaKey = KeyTranslate(args.VirtualKey, args.KeyStatus);
+
+            Keyboard.SetKey(xnaKey);
+
+            _lastEnqueuedKeyChar = new KeyChar();
+            _lastEnqueuedKeyChar.Key = xnaKey;
+            TextQueue.Enqueue(_lastEnqueuedKeyChar);
+        }
+
+        private void Window_CharacterReceived(CoreWindow sender, CharacterReceivedEventArgs args)
+        {
+            if (_lastEnqueuedKeyChar != null)
+                _lastEnqueuedKeyChar.Character = (char)args.KeyCode;
+        }
+
+        private void CoreWindow_SizeChanged(CoreWindow sender, WindowSizeChangedEventArgs args)
+        {
+            // If the window is resized then also 
+            // drop any current key states.
+            Keyboard.Clear();
+
+            // required of input can stop working if we change focus
+            WakeupKeyboardInput();
+        }
+
+        private void CoreWindow_Activated(CoreWindow sender, WindowActivatedEventArgs args)
+        {
+            // Forget about the held keys when we lose focus as we don't
+            // receive key events for them while we are in the background
+            if (args.WindowActivationState == CoreWindowActivationState.Deactivated)
+                Keyboard.Clear();
+
+            // required of input can stop working if we change focus
+            WakeupKeyboardInput();
+        }
+
+        private void CoreWindow_VisibilityChanged(CoreWindow sender, VisibilityChangedEventArgs args)
+        {
+            // Forget about the held keys when we disappear as we don't
+            // receive key events for them while we are in the background
+            if (!args.Visible)
+                Keyboard.Clear();
+
+            // required of input can stop working if we change focus
+            WakeupKeyboardInput();
+        }
+
+        private static void WakeupKeyboardInput()
+        {
+            if (Window.Current != null)
+                Window.Current.CoreWindow.IsInputEnabled = true;
+            CoreWindow.GetForCurrentThread().IsInputEnabled = true;
+        }
+    }
+}
diff --git a/MonoGame.Framework/WindowsUniversal/UAPFrameworkView.cs b/MonoGame.Framework/WindowsUniversal/UAPFrameworkView.cs
new file mode 100644
index 00000000000..5d04926b350
--- /dev/null
+++ b/MonoGame.Framework/WindowsUniversal/UAPFrameworkView.cs
@@ -0,0 +1,94 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.Core;
+using Windows.UI.Core;
+using Windows.ApplicationModel.Activation;
+
+namespace Microsoft.Xna.Framework
+{
+    class UAPFrameworkView<T> : IFrameworkView
+        where T : Game, new()
+    {
+        public UAPFrameworkView(Action<T, IActivatedEventArgs> gameConstructorCustomizationDelegate)
+        {
+            this._gameConstructorCustomizationDelegate = gameConstructorCustomizationDelegate;
+        }
+
+        private Action<T, IActivatedEventArgs> _gameConstructorCustomizationDelegate = null;
+        private CoreApplicationView _applicationView;
+        private T _game;
+
+        public void Initialize(CoreApplicationView applicationView)
+        {
+            _applicationView = applicationView;
+
+            _applicationView.Activated += ViewActivated;
+        }
+
+        private void ViewActivated(CoreApplicationView sender, IActivatedEventArgs args)
+        {
+            if (args.Kind == ActivationKind.Launch)
+            {
+                // Save any launch parameters to be parsed by the platform.
+                UAPGamePlatform.LaunchParameters = ((LaunchActivatedEventArgs)args).Arguments;
+                UAPGamePlatform.PreviousExecutionState = ((LaunchActivatedEventArgs)args).PreviousExecutionState;
+
+                // Construct the game.                
+                _game = new T();
+
+                //Initializes it, if delegate was provided
+                if (_gameConstructorCustomizationDelegate != null)
+                    _gameConstructorCustomizationDelegate(_game, args);
+
+            }
+            else if (args.Kind == ActivationKind.Protocol)
+            {
+                // Save any protocol launch parameters to be parsed by the platform.
+                var protocolArgs = args as ProtocolActivatedEventArgs;
+                UAPGamePlatform.LaunchParameters = protocolArgs.Uri.AbsoluteUri;
+                UAPGamePlatform.PreviousExecutionState = protocolArgs.PreviousExecutionState;
+
+                // Construct the game if it does not exist
+                // Protocol can be used to reactivate a suspended game
+                if (_game == null)
+                {
+                    _game = new T();
+
+                    //Initializes it, if delegate was provided
+                    if (_gameConstructorCustomizationDelegate != null)
+                        _gameConstructorCustomizationDelegate(_game, args);
+                }
+            }
+        }
+
+        public void Load(string entryPoint)
+        {
+        }
+
+        public void Run()
+        {
+            // Initialize and run the game.
+            _game.Run();
+        }
+       
+        public void SetWindow(CoreWindow window)
+        {
+            // Initialize the singleton window.
+            UAPGameWindow.Instance.Initialize(window, null, UAPGamePlatform.TouchQueue);
+        }
+
+        public void Uninitialize()
+        {
+            // TODO: I have no idea when and if this is
+            // called... as of Win8 build 8250 this seems 
+            // like its never called.
+        }
+    }
+}
diff --git a/MonoGame.Framework/WindowsUniversal/UAPGamePlatform.cs b/MonoGame.Framework/WindowsUniversal/UAPGamePlatform.cs
new file mode 100644
index 00000000000..c8a73742d83
--- /dev/null
+++ b/MonoGame.Framework/WindowsUniversal/UAPGamePlatform.cs
@@ -0,0 +1,219 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Diagnostics;
+
+//using Microsoft.Xna.Framework.Audio;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input.Touch;
+using Windows.ApplicationModel;
+using Windows.ApplicationModel.Activation;
+using Windows.ApplicationModel.Core;
+using Windows.System.Threading;
+using Windows.UI.ViewManagement;
+using Windows.UI.Xaml.Media;
+using Windows.UI.Xaml;
+using Windows.UI.Core;
+using Microsoft.Xna.Framework.Input;
+
+namespace Microsoft.Xna.Framework
+{
+    class UAPGamePlatform : GamePlatform
+    {
+        internal static string LaunchParameters;
+
+        internal static readonly TouchQueue TouchQueue = new TouchQueue();
+
+        internal static ApplicationExecutionState PreviousExecutionState { get; set; }
+
+        public UAPGamePlatform(Game game)
+            : base(game)
+        {
+            // Setup the game window.
+            Window = UAPGameWindow.Instance;
+			UAPGameWindow.Instance.Game = game;
+            UAPGameWindow.Instance.RegisterCoreWindowService();
+
+            // Setup the launch parameters.
+            // - Parameters can optionally start with a forward slash.
+            // - Keys can be separated from values by a colon or equals sign
+            // - Double quotes can be used to enclose spaces in a key or value.
+            int pos = 0;
+            int paramStart = 0;
+            bool inQuotes = false;
+            var keySeperators = new char[] { ':', '=' };
+
+            while (pos <= LaunchParameters.Length)
+            {
+                string arg = string.Empty;
+                if (pos < LaunchParameters.Length)
+                {
+                    char c = LaunchParameters[pos];
+                    if (c == '"')
+                        inQuotes = !inQuotes;
+                    else if ((c == ' ') && !inQuotes)
+                    {
+                        arg = LaunchParameters.Substring(paramStart, pos - paramStart).Replace("\"", "");
+                        paramStart = pos + 1;
+                    }
+                }
+                else
+                {
+                    arg = LaunchParameters.Substring(paramStart).Replace("\"", "");
+                }
+                ++pos;
+
+                if (string.IsNullOrWhiteSpace(arg))
+                    continue;
+
+                string key = string.Empty;
+                string value = string.Empty;
+                int keyStart = 0;
+
+                if (arg.StartsWith("/"))
+                    keyStart = 1;
+
+                if (arg.Length > keyStart)
+                {
+                    int keyEnd = arg.IndexOfAny(keySeperators, keyStart);
+
+                    if (keyEnd >= 0)
+                    {
+                        key = arg.Substring(keyStart, keyEnd - keyStart);
+                        int valueStart = keyEnd + 1;
+                        if (valueStart < arg.Length)
+                            value = arg.Substring(valueStart);
+                    }
+                    else
+                    {
+                        key = arg.Substring(keyStart);
+                    }
+
+                    Game.LaunchParameters.Add(key, value);
+                }
+            }
+
+            CoreApplication.Suspending += this.CoreApplication_Suspending;
+
+            Game.PreviousExecutionState = PreviousExecutionState;
+        }
+
+        private void CoreApplication_Suspending(object sender, SuspendingEventArgs e)
+        {
+            if (this.Game.GraphicsDevice != null)
+                this.Game.GraphicsDevice.Trim();
+        }
+
+        public override GameRunBehavior DefaultRunBehavior
+        {
+            get { return GameRunBehavior.Synchronous; }
+        }
+
+        public override void RunLoop()
+        {
+            UAPGameWindow.Instance.RunLoop();
+        }
+
+        public override void StartRunLoop()
+        {
+            var workItemHandler = new WorkItemHandler((action) =>
+            {
+                while (true)
+                {
+                    UAPGameWindow.Instance.Tick();
+                }
+            });
+            var tickWorker = ThreadPool.RunAsync(workItemHandler, WorkItemPriority.High, WorkItemOptions.TimeSliced);
+        }
+        
+        public override void Exit()
+        {
+            if (!UAPGameWindow.Instance.IsExiting)
+            {
+				UAPGameWindow.Instance.IsExiting = true;
+                Application.Current.Exit();
+            }
+        }
+
+        public override bool BeforeUpdate(GameTime gameTime)
+        {
+            TouchQueue.ProcessQueued();
+            return true;
+        }
+
+        public override bool BeforeDraw(GameTime gameTime)
+        {
+            var device = Game.GraphicsDevice;
+            if (device != null)
+            {
+				// For a UAP app we need to re-apply the
+				// render target before every draw.  
+				// 
+				// I guess the OS changes it and doesn't restore it?
+				device.ResetRenderTargets();
+            }
+
+            return true;
+        }
+
+        public override void EnterFullScreen()
+        {
+            UAPGameWindow.Instance.AppView.TryEnterFullScreenMode();
+		}
+
+		public override void ExitFullScreen()
+        {
+            UAPGameWindow.Instance.AppView.ExitFullScreenMode();
+        }
+
+        internal override void OnPresentationChanged(PresentationParameters pp)
+        {
+            if (pp.IsFullScreen)
+                EnterFullScreen();
+            else
+                ExitFullScreen();
+        }
+
+        public override void EndScreenDeviceChange(string screenDeviceName, int clientWidth, int clientHeight)
+        {
+        }
+
+        public override void BeginScreenDeviceChange(bool willBeFullScreen)
+        {
+        }
+
+        public override void Log(string Message)
+        {
+            Debug.WriteLine(Message);
+        }
+
+        public override void Present()
+        {
+            var device = Game.GraphicsDevice;
+            if ( device != null )
+                device.Present();
+        }
+
+        protected override void OnIsMouseVisibleChanged() 
+        {
+			UAPGameWindow.Instance.SetCursor(Game.IsMouseVisible);
+        }
+		
+        protected override void Dispose(bool disposing)
+        {
+            // Make sure we dispose the graphics system.
+            var graphicsDeviceManager = Game.graphicsDeviceManager;
+            if (graphicsDeviceManager != null)
+                graphicsDeviceManager.Dispose();
+
+			UAPGameWindow.Instance.Dispose();
+			
+			base.Dispose(disposing);
+        }
+    }
+}
diff --git a/MonoGame.Framework/WindowsUniversal/UAPGameWindow.cs b/MonoGame.Framework/WindowsUniversal/UAPGameWindow.cs
new file mode 100644
index 00000000000..9bd852ca591
--- /dev/null
+++ b/MonoGame.Framework/WindowsUniversal/UAPGameWindow.cs
@@ -0,0 +1,405 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+using Windows.UI.Core;
+using Windows.UI.ViewManagement;
+using Windows.UI.Xaml;
+using Windows.Graphics.Display;
+using Windows.Phone.UI.Input;
+
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using Microsoft.Xna.Framework.Input.Touch;
+using Windows.UI.Xaml.Controls;
+
+namespace Microsoft.Xna.Framework
+{
+    partial class UAPGameWindow : GameWindow
+    {
+        private DisplayOrientation _supportedOrientations;
+        private DisplayOrientation _orientation;
+        private CoreWindow _coreWindow;
+        private DisplayInformation _dinfo;
+        private ApplicationView _appView;
+        private Rectangle _viewBounds;
+
+        private object _eventLocker = new object();
+
+        private InputEvents _inputEvents;
+        private bool _isSizeChanged = false;
+        private Rectangle _newViewBounds;
+        private bool _isOrientationChanged = false;
+        private DisplayOrientation _newOrientation;
+        private bool _isFocusChanged = false;
+        private CoreWindowActivationState _newActivationState;
+        private bool _backPressed = false;
+
+        #region Internal Properties
+
+        internal Game Game { get; set; }
+
+        public ApplicationView AppView { get { return _appView; } }
+
+        internal bool IsExiting { get; set; }
+
+        #endregion
+
+        #region Public Properties
+
+        public override IntPtr Handle { get { return Marshal.GetIUnknownForObject(_coreWindow); } }
+
+        public override string ScreenDeviceName { get { return String.Empty; } } // window.Title
+
+        public override Rectangle ClientBounds { get { return _viewBounds; } }
+
+        public override bool AllowUserResizing
+        {
+            get { return false; }
+            set
+            {
+                // You cannot resize a Metro window!
+            }
+        }
+
+        public override DisplayOrientation CurrentOrientation
+        {
+            get { return _orientation; }
+        }
+
+        private UAPGamePlatform Platform { get { return Game.Instance.Platform as UAPGamePlatform; } }
+
+        protected internal override void SetSupportedOrientations(DisplayOrientation orientations)
+        {
+            // We don't want to trigger orientation changes 
+            // when no preference is being changed.
+            if (_supportedOrientations == orientations)
+                return;
+
+            _supportedOrientations = orientations;
+
+            DisplayOrientations supported;
+            if (orientations == DisplayOrientation.Default)
+            {
+                // Make the decision based on the preferred backbuffer dimensions.
+                var manager = Game.graphicsDeviceManager;
+                if (manager.PreferredBackBufferWidth > manager.PreferredBackBufferHeight)
+                    supported = FromOrientation(DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight);
+                else
+                    supported = FromOrientation(DisplayOrientation.Portrait | DisplayOrientation.PortraitDown);
+            }
+            else
+                supported = FromOrientation(orientations);
+
+            DisplayInformation.AutoRotationPreferences = supported;
+        }
+
+        #endregion
+
+        static public UAPGameWindow Instance { get; private set; }
+
+        static UAPGameWindow()
+        {
+            Instance = new UAPGameWindow();
+        }
+
+        public void Initialize(CoreWindow coreWindow, UIElement inputElement, TouchQueue touchQueue)
+        {
+            _coreWindow = coreWindow;
+            _inputEvents = new InputEvents(_coreWindow, inputElement, touchQueue);
+
+            _dinfo = DisplayInformation.GetForCurrentView();
+            _appView = ApplicationView.GetForCurrentView();
+
+            // Set a min size that is reasonable knowing someone might try
+            // to use some old school resolution like 640x480.
+            var minSize = new Windows.Foundation.Size(640 / _dinfo.RawPixelsPerViewPixel, 480 / _dinfo.RawPixelsPerViewPixel);
+            _appView.SetPreferredMinSize(minSize);
+
+            _orientation = ToOrientation(_dinfo.CurrentOrientation);
+            _dinfo.OrientationChanged += DisplayProperties_OrientationChanged;
+
+            _coreWindow.SizeChanged += Window_SizeChanged;
+
+            _coreWindow.Closed += Window_Closed;
+            _coreWindow.Activated += Window_FocusChanged;
+
+            if (Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Phone.UI.Input.HardwareButtons"))
+                Windows.Phone.UI.Input.HardwareButtons.BackPressed += this.HardwareButtons_BackPressed;
+
+            SetViewBounds(_appView.VisibleBounds.Width, _appView.VisibleBounds.Height);
+
+            SetCursor(false);
+
+        }
+
+        internal void RegisterCoreWindowService()
+        {
+            // Register the CoreWindow with the services registry
+            Game.Services.AddService(typeof(CoreWindow), _coreWindow);
+        }
+
+        private void Window_FocusChanged(CoreWindow sender, WindowActivatedEventArgs args)
+        {
+            lock (_eventLocker)
+            {
+                _isFocusChanged = true;
+                _newActivationState = args.WindowActivationState;
+            }
+        }
+
+        private void UpdateFocus()
+        {
+            lock (_eventLocker)
+            {
+                _isFocusChanged = false;
+
+                if (_newActivationState == CoreWindowActivationState.Deactivated)
+                    Platform.IsActive = false;
+                else
+                    Platform.IsActive = true;
+            }
+        }
+
+        private void Window_Closed(CoreWindow sender, CoreWindowEventArgs args)
+        {
+            Game.SuppressDraw();
+            Game.Platform.Exit();
+        }
+
+        private void SetViewBounds(double width, double height)
+        {
+            var pixelWidth = Math.Max(1, (int)Math.Round(width * _dinfo.RawPixelsPerViewPixel));
+            var pixelHeight = Math.Max(1, (int)Math.Round(height * _dinfo.RawPixelsPerViewPixel));
+            _viewBounds = new Rectangle(0, 0, pixelWidth, pixelHeight);
+        }
+
+        private void Window_SizeChanged(object sender, WindowSizeChangedEventArgs args)
+        {
+            lock (_eventLocker)
+            {
+                _isSizeChanged = true;
+                var pixelWidth  = Math.Max(1, (int)Math.Round(args.Size.Width * _dinfo.RawPixelsPerViewPixel));
+                var pixelHeight = Math.Max(1, (int)Math.Round(args.Size.Height * _dinfo.RawPixelsPerViewPixel));
+                _newViewBounds = new Rectangle(0, 0, pixelWidth, pixelHeight);
+            }
+        }
+
+        private void UpdateSize()
+        {
+            lock (_eventLocker)
+            {
+                _isSizeChanged = false;
+
+                var manager = Game.graphicsDeviceManager;
+
+                // Set the new client bounds.
+                _viewBounds = _newViewBounds;
+
+                // Set the default new back buffer size and viewport, but this
+                // can be overloaded by the two events below.
+
+                manager.IsFullScreen = _appView.IsFullScreenMode;
+                manager.PreferredBackBufferWidth = _viewBounds.Width;
+                manager.PreferredBackBufferHeight = _viewBounds.Height;
+                manager.ApplyChanges();
+
+                // Set the new view state which will trigger the 
+                // Game.ApplicationViewChanged event and signal
+                // the client size changed event.
+                OnClientSizeChanged();
+            }
+        }
+
+        private static DisplayOrientation ToOrientation(DisplayOrientations orientations)
+        {
+            var result = DisplayOrientation.Default;
+            if ((orientations & DisplayOrientations.Landscape) != 0)
+                result |= DisplayOrientation.LandscapeLeft;
+            if ((orientations & DisplayOrientations.LandscapeFlipped) != 0)
+                result |= DisplayOrientation.LandscapeRight;
+            if ((orientations & DisplayOrientations.Portrait) != 0)
+                result |= DisplayOrientation.Portrait;
+            if ((orientations & DisplayOrientations.PortraitFlipped) != 0)
+                result |= DisplayOrientation.PortraitDown;
+
+            return result;
+        }
+
+        private static DisplayOrientations FromOrientation(DisplayOrientation orientation)
+        {
+            var result = DisplayOrientations.None;
+            if ((orientation & DisplayOrientation.LandscapeLeft) != 0)
+                result |= DisplayOrientations.Landscape;
+            if ((orientation & DisplayOrientation.LandscapeRight) != 0)
+                result |= DisplayOrientations.LandscapeFlipped;
+            if ((orientation & DisplayOrientation.Portrait) != 0)
+                result |= DisplayOrientations.Portrait;
+            if ((orientation & DisplayOrientation.PortraitDown) != 0)
+                result |= DisplayOrientations.PortraitFlipped;
+
+            return result;
+        }
+
+        internal void SetClientSize(int width, int height)
+        {
+            if (_appView.IsFullScreenMode)
+                return;
+
+            if (_viewBounds.Width == width &&
+                _viewBounds.Height == height)
+                return;
+
+            var viewSize = new Windows.Foundation.Size(width / _dinfo.RawPixelsPerViewPixel, height / _dinfo.RawPixelsPerViewPixel);
+
+            //_appView.SetPreferredMinSize(viewSize);
+            if (!_appView.TryResizeView(viewSize))
+            {
+                // TODO: What now?
+            }
+        }
+
+        private void DisplayProperties_OrientationChanged(DisplayInformation dinfo, object sender)
+        {
+            lock(_eventLocker)
+            {
+                _isOrientationChanged = true;
+                _newOrientation = ToOrientation(dinfo.CurrentOrientation);
+            }
+        }
+
+        private void UpdateOrientation()
+        {
+            lock (_eventLocker)
+            {
+                _isOrientationChanged = false;
+
+                // Set the new orientation.
+                _orientation = _newOrientation;
+
+                // Call the user callback.
+                OnOrientationChanged();
+
+                // If we have a valid client bounds then update the graphics device.
+                if (_viewBounds.Width > 0 && _viewBounds.Height > 0)
+                    Game.graphicsDeviceManager.ApplyChanges();
+            }
+        }
+
+        private void HardwareButtons_BackPressed(object sender, BackPressedEventArgs e)
+        {
+            // We need to manually hide the keyboard input UI when the back button is pressed
+            if (KeyboardInput.IsVisible)
+                KeyboardInput.Cancel(null);
+            else
+                _backPressed = true;
+
+            e.Handled = true;
+        }
+
+        private void UpdateBackButton()
+        {
+            GamePad.Back = _backPressed;
+            _backPressed = false;
+        }
+
+        protected override void SetTitle(string title)
+        {
+            Debug.WriteLine("WARNING: GameWindow.Title has no effect under UWP.");
+        }
+
+        internal void SetCursor(bool visible)
+        {
+            if ( _coreWindow == null )
+                return;
+
+            var asyncResult = _coreWindow.Dispatcher.RunIdleAsync( (e) =>
+           {
+               if (visible)
+                   _coreWindow.PointerCursor = new CoreCursor(CoreCursorType.Arrow, 0);
+               else
+                   _coreWindow.PointerCursor = null;
+           });
+        }
+
+        internal void RunLoop()
+        {
+            SetCursor(Game.IsMouseVisible);
+            _coreWindow.Activate();
+
+            while (true)
+            {
+                // Process events incoming to the window.
+                _coreWindow.Dispatcher.ProcessEvents(CoreProcessEventsOption.ProcessAllIfPresent);
+
+                Tick();
+
+                if (IsExiting)
+                    break;
+            }
+        }
+
+        void ProcessWindowEvents()
+        {
+            // Update input
+            _inputEvents.UpdateState();
+
+            // Update TextInput
+            if(!_inputEvents.TextQueue.IsEmpty)
+            {
+                InputEvents.KeyChar ch;
+                while (_inputEvents.TextQueue.TryDequeue(out ch))
+                    OnTextInput(_coreWindow, new TextInputEventArgs(ch.Character, ch.Key));
+            }
+
+            // Update size
+            if (_isSizeChanged)
+                UpdateSize();
+
+            // Update orientation
+            if (_isOrientationChanged)
+                UpdateOrientation();
+
+            // Update focus
+            if (_isFocusChanged)
+                UpdateFocus();
+
+            // Update back button
+            UpdateBackButton();
+        }
+
+        internal void Tick()
+        {
+            // Update state based on window events.
+            ProcessWindowEvents();
+
+            // Update and render the game.
+            if (Game != null)
+                Game.Tick();
+        }
+
+        #region Public Methods
+
+        public void Dispose()
+        {
+            //window.Dispose();
+        }
+
+        public override void BeginScreenDeviceChange(bool willBeFullScreen)
+        {
+        }
+
+        public override void EndScreenDeviceChange(string screenDeviceName, int clientWidth, int clientHeight)
+        {
+
+        }
+
+        #endregion
+    }
+}
+
diff --git a/MonoGame.Framework/WindowsUniversal/XamlGame.cs b/MonoGame.Framework/WindowsUniversal/XamlGame.cs
new file mode 100644
index 00000000000..d5d8466b964
--- /dev/null
+++ b/MonoGame.Framework/WindowsUniversal/XamlGame.cs
@@ -0,0 +1,74 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Microsoft.Xna.Framework;
+using Windows.UI.Core;
+using Windows.UI.Xaml.Controls;
+
+
+namespace MonoGame.Framework
+{
+    /// <summary>
+    /// Static class for initializing a Game object for a XAML application.
+    /// </summary>
+    /// <typeparam name="T">A class derived from Game with a public parameterless constructor.</typeparam>
+    [CLSCompliant(false)]
+    public static class XamlGame<T>
+        where T : Game, new()
+    {
+        /// <summary>
+        /// Creates your Game class initializing it to work within a XAML application window.
+        /// </summary>
+        /// <param name="launchParameters">The command line arguments from launch.</param>
+        /// <param name="window">The core window object.</param>
+        /// <param name="swapChainPanel">The XAML SwapChainPanel to which we render the scene and receive input events.</param>
+        /// <returns>Returns an instance of T generated with default parameterless T constructor</returns>
+        static public T Create(string launchParameters, CoreWindow window, SwapChainPanel swapChainPanel)
+        {
+            return Create(() => new T(), launchParameters, window, swapChainPanel);
+        }
+
+        /// <summary>
+        /// Creates your Game class initializing it with <paramref name="gameConstructor"/> to work within a XAML application window.
+        /// </summary>
+        /// <param name="gameConstructor">The method to construct T</param>
+        /// <param name="launchParameters">The command line arguments from launch.</param>
+        /// <param name="window">The core window object.</param>
+        /// <param name="swapChainPanel">The XAML SwapChainPanel to which we render the scene and receive input events.</param>
+        /// <returns>Returns an instance of T generated with <paramref name="gameConstructor"/></returns>
+        static public T Create(Func<T> gameConstructor, string launchParameters, CoreWindow window, SwapChainPanel swapChainPanel)
+        {
+            if (gameConstructor == null)
+                throw new NullReferenceException(nameof(gameConstructor));
+            if (launchParameters == null)
+                throw new NullReferenceException("The launch parameters cannot be null!");
+            if (window == null)
+                throw new NullReferenceException("The window cannot be null!");
+            if (swapChainPanel == null)
+                throw new NullReferenceException("The swap chain panel cannot be null!");
+
+            // Save any launch parameters to be parsed by the platform.
+            UAPGamePlatform.LaunchParameters = launchParameters;
+
+            // Setup the window class.
+            UAPGameWindow.Instance.Initialize(window, swapChainPanel, UAPGamePlatform.TouchQueue);
+
+            // Construct the game.
+            var game = gameConstructor();
+
+            // Set the swap chain panel on the graphics mananger.
+            if (game.graphicsDeviceManager == null)
+                throw new NullReferenceException("You must create the GraphicsDeviceManager in the Game constructor!");
+            game.graphicsDeviceManager.SwapChainPanel = swapChainPanel;
+
+            // Start running the game.
+            game.Run(GameRunBehavior.Asynchronous);
+
+            // Return the created game object.
+            return game;
+        }
+
+    }
+}
diff --git a/MonoGame.Framework/iOS/Devices/Sensors/Accelerometer.cs b/MonoGame.Framework/iOS/Devices/Sensors/Accelerometer.cs
new file mode 100644
index 00000000000..92a6c3a48f3
--- /dev/null
+++ b/MonoGame.Framework/iOS/Devices/Sensors/Accelerometer.cs
@@ -0,0 +1,100 @@
+using System;
+
+using Microsoft.Xna.Framework;
+
+using CoreMotion;
+using Foundation;
+
+namespace Microsoft.Devices.Sensors
+{
+	public sealed class Accelerometer : SensorBase<AccelerometerReading>
+	{
+        static readonly int MaxSensorCount = 10;
+        static int instanceCount;
+		private static bool started = false;
+		private static SensorState state = IsSupported ? SensorState.Initializing : SensorState.NotSupported;
+
+		public static bool IsSupported
+		{
+			get { return motionManager.AccelerometerAvailable; }
+		}
+		public SensorState State
+		{
+			get { return state; }
+		}
+
+		private static event CMAccelerometerHandler readingChanged;
+
+		public Accelerometer()
+		{
+			if (!IsSupported)
+                throw new AccelerometerFailedException("Failed to start accelerometer data acquisition. No default sensor found.", -1);
+            else if (instanceCount >= MaxSensorCount)
+                throw new SensorFailedException("The limit of 10 simultaneous instances of the Accelerometer class per application has been exceeded.");
+
+            ++instanceCount;
+
+			this.TimeBetweenUpdatesChanged += this.UpdateInterval;
+			readingChanged += ReadingChangedHandler;
+
+		}
+
+        protected override void Dispose (bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                if (disposing)
+                {
+                    if (started)
+                        Stop();
+                    --instanceCount;
+                }
+            }
+            base.Dispose(disposing);
+        }
+
+		public override void Start()
+		{
+			if (started == false)
+			{
+				motionManager.StartAccelerometerUpdates(NSOperationQueue.CurrentQueue, AccelerometerHandler);
+				started = true;
+				state = SensorState.Ready;
+			}
+			else
+                throw new AccelerometerFailedException("Failed to start accelerometer data acquisition. Data acquisition already started.", -1);
+		}
+
+		public override void Stop()
+		{
+			motionManager.StopAccelerometerUpdates();
+			started = false;
+			state = SensorState.Disabled;
+		}
+
+		private void AccelerometerHandler(CMAccelerometerData data, NSError error)
+		{
+			readingChanged(data, error);
+		}
+
+		private void ReadingChangedHandler(CMAccelerometerData data, NSError error)
+        {
+            AccelerometerReading reading = new AccelerometerReading();
+            this.IsDataValid = error == null;
+            if (this.IsDataValid)
+            {
+                this.IsDataValid = true;
+                reading.Acceleration = new Vector3((float)data.Acceleration.X, (float)data.Acceleration.Y, (float)data.Acceleration.Z);
+                reading.Timestamp = DateTime.UtcNow;
+                this.CurrentValue = reading;
+                this.IsDataValid = error == null;
+            }
+		}
+
+		private void UpdateInterval(object sender, EventArgs args)
+		{
+			motionManager.AccelerometerUpdateInterval = this.TimeBetweenUpdates.TotalSeconds;
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/iOS/Devices/Sensors/Compass.cs b/MonoGame.Framework/iOS/Devices/Sensors/Compass.cs
new file mode 100644
index 00000000000..e7ed8bf37b9
--- /dev/null
+++ b/MonoGame.Framework/iOS/Devices/Sensors/Compass.cs
@@ -0,0 +1,126 @@
+using System;
+
+using Microsoft.Xna.Framework;
+
+using CoreMotion;
+using Foundation;
+
+namespace Microsoft.Devices.Sensors
+{
+    public sealed class Compass : SensorBase<CompassReading>
+    {
+        static readonly int MaxSensorCount = 10;
+        static int instanceCount;
+        private static bool started = false;
+        private static SensorState state = IsSupported ? SensorState.Initializing : SensorState.NotSupported;
+        private bool calibrate = false;
+
+        public event EventHandler<CalibrationEventArgs> Calibrate;
+
+        public static bool IsSupported
+        {
+            get { return motionManager.DeviceMotionAvailable; }
+        }
+        public SensorState State
+        {
+            get { return state; }
+        }
+
+        private static event CMDeviceMotionHandler readingChanged;
+
+        public Compass()
+        {
+            if (!IsSupported)
+                throw new SensorFailedException("Failed to start compass data acquisition. No default sensor found.");
+            else if (instanceCount >= MaxSensorCount)
+                throw new SensorFailedException("The limit of 10 simultaneous instances of the Compass class per application has been exceeded.");
+
+            ++instanceCount;
+
+            this.TimeBetweenUpdatesChanged += this.UpdateInterval;
+            readingChanged += ReadingChangedHandler;
+        }
+
+        protected override void Dispose (bool disposing)
+        {
+            if (!IsDisposed)
+            {
+                if (disposing)
+                {
+                    if (started)
+                        Stop();
+                    --instanceCount;
+                }
+            }
+            base.Dispose(disposing);
+        }
+
+        public override void Start()
+        {
+            if (started == false)
+            {
+                // For true north use CMAttitudeReferenceFrame.XTrueNorthZVertical, but be aware that it requires location service
+                motionManager.StartDeviceMotionUpdates(CMAttitudeReferenceFrame.XMagneticNorthZVertical, NSOperationQueue.CurrentQueue, MagnetometerHandler);
+                started = true;
+                state = SensorState.Ready;
+            }
+            else
+                throw new SensorFailedException("Failed to start compass data acquisition. Data acquisition already started.");
+        }
+
+        public override void Stop()
+        {
+            motionManager.StopDeviceMotionUpdates();
+            started = false;
+            state = SensorState.Disabled;
+        }
+
+        private void MagnetometerHandler(CMDeviceMotion magnetometerData, NSError error)
+        {
+            readingChanged(magnetometerData, error);
+        }
+
+        private void ReadingChangedHandler(CMDeviceMotion data, NSError error)
+        {
+            CompassReading reading = new CompassReading();
+            this.IsDataValid = error == null;
+            if (this.IsDataValid)
+            {
+                reading.MagnetometerReading = new Vector3((float)data.MagneticField.Field.Y, (float)-data.MagneticField.Field.X, (float)data.MagneticField.Field.Z);
+                reading.TrueHeading = Math.Atan2(reading.MagnetometerReading.Y, reading.MagnetometerReading.X) / Math.PI * 180;
+                reading.MagneticHeading = reading.TrueHeading;
+                switch (data.MagneticField.Accuracy)
+                {
+                    case CMMagneticFieldCalibrationAccuracy.High:
+                        reading.HeadingAccuracy = 5d;
+                        break;
+                    case CMMagneticFieldCalibrationAccuracy.Medium:
+                        reading.HeadingAccuracy = 30d;
+                        break;
+                    case CMMagneticFieldCalibrationAccuracy.Low:
+                        reading.HeadingAccuracy = 45d;
+                        break;
+                }
+
+                // Send calibrate event if needed
+                if (data.MagneticField.Accuracy == CMMagneticFieldCalibrationAccuracy.Uncalibrated)
+                {
+                    if (this.calibrate == false)
+                        EventHelpers.Raise(this, Calibrate, new CalibrationEventArgs());
+                    this.calibrate = true;
+                }
+                else if (this.calibrate == true)
+                    this.calibrate = false;
+
+                reading.Timestamp = DateTime.UtcNow;
+                this.CurrentValue = reading;
+            }
+        }
+
+        private void UpdateInterval(object sender, EventArgs args)
+        {
+            motionManager.MagnetometerUpdateInterval = this.TimeBetweenUpdates.TotalSeconds;
+        }
+    }
+}
+
diff --git a/MonoGame.Framework/iOS/GamerServices/Guide.cs b/MonoGame.Framework/iOS/GamerServices/Guide.cs
new file mode 100644
index 00000000000..ddf0f7441e3
--- /dev/null
+++ b/MonoGame.Framework/iOS/GamerServices/Guide.cs
@@ -0,0 +1,647 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009-2012 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+1. Definitions
+
+The terms "reproduce," "reproduction," "derivative works," and "distribution"
+have the same meaning here as under U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the
+software.
+
+A "contributor" is any person that distributes its contribution under this
+license.
+
+"Licensed patents" are a contributor's patent claims that read directly on its
+contribution.
+
+2. Grant of Rights
+
+(A) Copyright Grant- Subject to the terms of this license, including the
+license conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free copyright license to reproduce its
+contribution, prepare derivative works of its contribution, and distribute its
+contribution or any derivative works that you create.
+
+(B) Patent Grant- Subject to the terms of this license, including the license
+conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free license under its licensed patents to
+make, have made, use, sell, offer for sale, import, and/or otherwise dispose of
+its contribution in the software or derivative works of the contribution in the
+software.
+
+3. Conditions and Limitations
+
+(A) No Trademark License- This license does not grant you rights to use any
+contributors' name, logo, or trademarks.
+
+(B) If you bring a patent claim against any contributor over patents that you
+claim are infringed by the software, your patent license from such contributor
+to the software ends automatically.
+
+(C) If you distribute any portion of the software, you must retain all
+copyright, patent, trademark, and attribution notices that are present in the
+software.
+
+(D) If you distribute any portion of the software in source code form, you may
+do so only under this license by including a complete copy of this license with
+your distribution. If you distribute any portion of the software in compiled or
+object code form, you may only do so under a license that complies with this
+license.
+
+(E) The software is licensed "as-is." You bear the risk of using it. The
+contributors give no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the contributors exclude
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.
+*/
+#endregion License
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Remoting.Messaging;
+using System.Text;
+using System.Threading;
+using Foundation;
+using GameKit;
+using UIKit;
+using Microsoft.Xna.Framework.Net;
+using Microsoft.Xna.Framework.Input.Touch;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    class GuideAlreadyVisibleException : Exception
+    {
+        public GuideAlreadyVisibleException(string message)
+            : base(message)
+        {
+        }
+    }
+
+    /// <summary>
+    /// Used as a parent view controller for iOS 5 (and older) Game Center view controllers.
+    /// No longer used for iOS 6+ because it's unnecessary and generates runtime warnings.
+    /// (See comments for ShowGuideViewController below for more information.)
+    /// </summary>
+    class GuideViewController : UIViewController
+    {
+        UIViewController _parent;
+
+        public GuideViewController(UIViewController parent)
+        {
+            _parent = parent;
+        }
+
+        #region Autorotation for iOS 5 or older
+        [Obsolete]
+        public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation)
+        {
+            return _parent.ShouldAutorotateToInterfaceOrientation(toInterfaceOrientation);
+        }
+        #endregion
+
+        #region Autorotation for iOS 6 or newer
+        public override UIInterfaceOrientationMask GetSupportedInterfaceOrientations()
+        {
+            return _parent.GetSupportedInterfaceOrientations();
+        }
+
+        public override bool ShouldAutorotate()
+        {
+            return _parent.ShouldAutorotate();
+        }
+
+        public override UIInterfaceOrientation PreferredInterfaceOrientationForPresentation()
+        {
+            return _parent.PreferredInterfaceOrientationForPresentation();
+        }
+        #endregion
+
+        public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation)
+        {
+            /*
+            switch(this.InterfaceOrientation)
+            {
+            case UIInterfaceOrientation.LandscapeLeft:
+            case UIInterfaceOrientation.LandscapeRight:
+                Game.View.Frame = new System.Drawing.RectangleF(this.View.Frame.Location,new System.Drawing.SizeF(this.View.Frame.Height,this.View.Frame.Width));
+                break;
+            default:                
+                Game.View.Frame = new System.Drawing.RectangleF(this.View.Frame.Location,new System.Drawing.SizeF(this.View.Frame.Width,this.View.Frame.Height));
+                break;
+            }
+            //Game.View.Frame = this.View.Frame;
+            Console.WriteLine("Main View's Frame:" + Game.View.Frame);
+            */
+            base.DidRotate(fromInterfaceOrientation);
+        }
+    }
+
+    public static class Guide
+    {
+        private static GKPeerPickerController peerPickerController;
+        private static KeyboardInputViewController keyboardViewController;
+
+        private static GuideViewController guideViewController = null; // Only used for iOS 5 and older
+
+        private static GestureType prevGestures;
+        private static bool _isInitialised = false;
+        private static UIWindow _window;
+        private static UIViewController _gameViewController;
+
+        [CLSCompliant(false)]
+        public static GKMatch Match { get; private set; }
+
+        static Guide()
+        {
+            Initialise(Game.Instance);
+        }
+
+        internal static void Initialise(Game game)
+        {
+            if (!_isInitialised)
+            {
+                _window = (UIWindow)game.Services.GetService(typeof(UIWindow));
+                if (_window == null)
+                    throw new InvalidOperationException(
+                        "iOSGamePlatform must add the main UIWindow to Game.Services");
+
+                _gameViewController = (UIViewController)game.Services.GetService(typeof(UIViewController));
+                if (_gameViewController == null)
+                    throw new InvalidOperationException(
+                        "iOSGamePlatform must add the game UIViewController to Game.Services");
+
+                game.Exiting += Game_Exiting;
+
+                _isInitialised = true;
+            }
+        }
+
+        private static void Uninitialise(Game game)
+        {
+            game.Exiting -= Game_Exiting;
+            _window = null;
+            _gameViewController = null;
+            _isInitialised = false;
+        }
+
+        #region Properties
+
+        public static bool IsScreenSaverEnabled { get; set; }
+
+        private static bool isTrialMode;
+
+        public static bool IsTrialMode
+        {
+            get { return isTrialMode || SimulateTrialMode; }
+            set { isTrialMode = value; }
+        }
+
+        public static bool IsVisible { get; internal set; }
+
+        public static bool SimulateTrialMode { get; set; }
+
+        public static NotificationPosition NotificationPosition { get; set; }
+
+        #endregion
+
+        private static void Game_Exiting(object sender, EventArgs e)
+        {
+            Uninitialise((Game)sender);
+        }
+
+        private static void AssertInitialised()
+        {
+            if (!_isInitialised)
+                throw new InvalidOperationException(
+                    "Gamer services functionality has not been initialized.");
+        }
+
+        delegate string ShowKeyboardInputDelegate(
+            string title, string description, string defaultText, Object state, bool usePasswordMode);
+
+        private static string ShowKeyboardInput(
+            string title, string description, string defaultText, Object state, bool usePasswordMode)
+        {
+            string result = null;
+
+            IsVisible = true;
+            EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
+
+            keyboardViewController = new KeyboardInputViewController(
+                title, description, defaultText, usePasswordMode, _gameViewController);
+
+            UIApplication.SharedApplication.InvokeOnMainThread(delegate
+            {
+                _gameViewController.PresentViewController(keyboardViewController, true, null);
+
+                keyboardViewController.View.InputAccepted += (sender, e) =>
+                {
+                    _gameViewController.DismissViewController(true, null);
+                    result = keyboardViewController.View.Text;
+                    waitHandle.Set();
+                };
+
+                keyboardViewController.View.InputCanceled += (sender, e) =>
+                {
+                    _gameViewController.DismissViewController(true, null);
+                    waitHandle.Set();
+                };
+            });
+            waitHandle.WaitOne();
+
+            IsVisible = false;
+            return result;
+        }
+
+        public static IAsyncResult BeginShowKeyboardInput(
+            PlayerIndex player, string title, string description, string defaultText,
+            AsyncCallback callback, Object state)
+        {
+            AssertInitialised();
+            return BeginShowKeyboardInput(player, title, description, defaultText, callback, state, false);
+        }
+
+        public static IAsyncResult BeginShowKeyboardInput(
+            PlayerIndex player, string title, string description, string defaultText,
+            AsyncCallback callback, Object state, bool usePasswordMode)
+        {
+            AssertInitialised();
+
+            if (IsVisible)
+                throw new GuideAlreadyVisibleException("The function cannot be completed at this time: the Guide UI is already active. Wait until Guide.IsVisible is false before issuing this call.");
+
+            ShowKeyboardInputDelegate ski = ShowKeyboardInput;
+
+            return ski.BeginInvoke(title, description, defaultText, state, usePasswordMode, callback, ski);
+        }
+
+        public static string EndShowKeyboardInput(IAsyncResult result)
+        {
+            keyboardViewController = null;
+            return (result.AsyncState as ShowKeyboardInputDelegate).EndInvoke(result);
+        }
+
+        delegate Nullable<nint> ShowMessageBoxDelegate(
+            string title, string text, IEnumerable<string> buttons, nint focusButton, MessageBoxIcon icon);
+
+        private static Nullable<nint> ShowMessageBox(
+            string title, string text, IEnumerable<string> buttons, nint focusButton, MessageBoxIcon icon)
+        {
+            Nullable<nint> result = null;
+
+            IsVisible = true;
+            EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
+
+            UIApplication.SharedApplication.InvokeOnMainThread(delegate
+            {
+                UIAlertView alert = new UIAlertView();
+                alert.Title = title;
+                foreach (string btn in buttons)
+                {
+                    alert.AddButton(btn);
+                }
+                alert.Message = text;
+                alert.Dismissed += delegate(object sender, UIButtonEventArgs e)
+                { 
+                    result = e.ButtonIndex;
+                    waitHandle.Set();
+                };
+                alert.Show();
+            });
+            waitHandle.WaitOne();
+            IsVisible = false;
+
+            return result;
+        }
+
+        public static IAsyncResult BeginShowMessageBox(
+            PlayerIndex player, string title, string text, IEnumerable<string> buttons, nint focusButton,
+            MessageBoxIcon icon, AsyncCallback callback, Object state)
+        {
+            if (IsVisible)
+                throw new GuideAlreadyVisibleException("The function cannot be completed at this time: the Guide UI is already active. Wait until Guide.IsVisible is false before issuing this call.");
+
+            IsVisible = true;
+
+            ShowMessageBoxDelegate smb = ShowMessageBox; 
+
+            return smb.BeginInvoke(title, text, buttons, focusButton, icon, callback, smb);         
+        }
+
+        public static IAsyncResult BeginShowMessageBox(
+            string title, string text, IEnumerable<string> buttons, int focusButton, MessageBoxIcon icon,
+            AsyncCallback callback, Object state
+        )
+        {
+            return BeginShowMessageBox(PlayerIndex.One, title, text, buttons, focusButton, icon, callback, state);
+        }
+
+        public static Nullable<nint> EndShowMessageBox(IAsyncResult result)
+        {
+            return (result.AsyncState as ShowMessageBoxDelegate).EndInvoke(result);
+        }
+
+        public static void ShowMarketplace(PlayerIndex player)
+        {
+            AssertInitialised();
+
+            string bundleName = NSBundle.MainBundle.InfoDictionary[new NSString("CFBundleName")].ToString();
+            StringBuilder output = new StringBuilder();
+            foreach (char c in bundleName)
+            {
+                // Ampersand gets converted to "and"!!
+                if (c == '&')
+                    output.Append("and");
+
+                // All alphanumeric characters are added
+                if (char.IsLetterOrDigit(c))
+                    output.Append(c);
+            }
+            NSUrl url = new NSUrl("itms-apps://itunes.com/app/" + output.ToString());
+            if (!UIApplication.SharedApplication.OpenUrl(url))
+            {
+                // Error
+            }
+        }
+
+        public static void ShowSignIn(int paneCount, bool onlineOnly)
+        {
+            AssertInitialised();
+
+            if (paneCount != 1)
+            {
+                new ArgumentException("paneCount Can only be 1 on iPhone");
+                return;
+            }
+
+            if (GamerServicesComponent.LocalNetworkGamer == null)
+            {
+                GamerServicesComponent.LocalNetworkGamer = new LocalNetworkGamer();
+            }
+            else
+            {
+                GamerServicesComponent.LocalNetworkGamer.SignedInGamer.BeginAuthentication(null, null);
+            }
+        }
+
+        /// <summary>
+        /// Shows guide view controllers, e.g., Game Center view controllers.
+        /// In iOS 5 and older, the guide is presented using GuideViewController.
+        /// In iOS 6+, the guide is presented using the root view controller.
+        /// (The iOS 5 method generates runtime warnings.)
+        /// </summary>
+        /// <param name="viewController">The view controller to be shown, e.g., Game Center view controllers</param>
+        private static void ShowViewController(UIViewController viewController)
+        {
+            if (_window != null && viewController != null)
+            {
+                prevGestures = TouchPanel.EnabledGestures;
+                TouchPanel.EnabledGestures = GestureType.None;
+
+                if (!UIDevice.CurrentDevice.CheckSystemVersion(6, 0))
+                {
+                    // Show view controller the old way for iOS 5 and older
+                    if (guideViewController == null)
+                    {
+                        guideViewController = new GuideViewController(_gameViewController);
+                        _window.Add(guideViewController.View);
+                        guideViewController.View.Hidden = true;
+                    }
+
+#pragma warning disable 618
+                    // Disable PresentModalViewController warning, still need to support iOS 5 and older
+                    guideViewController.PresentModalViewController(viewController, true);
+#pragma warning restore 618
+                }
+                else
+                {
+                    // Show view controller the new way for iOS 6+
+                    _window.RootViewController.PresentViewController(viewController, true, delegate {});
+                }
+
+                IsVisible = true;
+            }
+        }
+
+        private static void HideViewController(UIViewController viewController)
+        {
+            if (!UIDevice.CurrentDevice.CheckSystemVersion(6, 0))
+            {
+#pragma warning disable 618
+                // Disable DismissModalViewControllerAnimated warning, still need to support iOS 5 and older
+				viewController.DismissModalViewController(true);
+#pragma warning restore 618
+            }
+            else
+            {
+                // Dismiss view controller for iOS 6+
+                viewController.DismissViewController(true, delegate {});
+            }
+
+            IsVisible = false;
+            TouchPanel.EnabledGestures = prevGestures;
+        }
+
+        public static void ShowLeaderboard()
+        {
+            AssertInitialised();
+
+            if ((Gamer.SignedInGamers.Count > 0) && (Gamer.SignedInGamers[0].IsSignedInToLive))
+            {
+                if (!UIDevice.CurrentDevice.CheckSystemVersion(6, 0))
+                {
+                    // GKLeaderboardViewController for iOS 5 and older
+                    var leaderboardController = new GKLeaderboardViewController();
+                    leaderboardController.DidFinish += delegate(object sender, EventArgs e)
+                    {
+                        HideViewController(leaderboardController);
+                    };
+
+                    ShowViewController(leaderboardController);
+                }
+                else
+                {
+                    // GKGameCenterViewController for iOS 6+
+                    var gameCenterController = new GKGameCenterViewController();
+                    gameCenterController.Finished += delegate(object sender, EventArgs e)
+                    {
+                        HideViewController(gameCenterController);
+                    };
+
+                    gameCenterController.ViewState = GKGameCenterViewControllerState.Leaderboards;
+                    ShowViewController(gameCenterController);
+                }
+            }
+            else
+            {
+                UIAlertView alert = new UIAlertView("Error", "You must be signed in to Game Center to view leaderboards.", null, "OK");
+                alert.Show();
+                ShowSignIn(1, true);
+            }
+        }
+
+        public static void ShowAchievements()
+        {
+            AssertInitialised();
+
+            if ((Gamer.SignedInGamers.Count > 0) && (Gamer.SignedInGamers[0].IsSignedInToLive))
+            {
+                if (!UIDevice.CurrentDevice.CheckSystemVersion(6, 0))
+                {
+                    // GKAchievementViewController for iOS 5 and older
+                    var achievementController = new GKAchievementViewController();
+                    achievementController.DidFinish += delegate(object sender, EventArgs e)
+                    {
+                        HideViewController(achievementController);
+                    };
+
+                    ShowViewController(achievementController);
+                }
+                else
+                {
+                    // GKGameCenterViewController for iOS 6+
+                    var gameCenterController = new GKGameCenterViewController();
+                    gameCenterController.Finished += delegate(object sender, EventArgs e)
+                    {
+                        HideViewController(gameCenterController);
+                    };
+
+                    gameCenterController.ViewState = GKGameCenterViewControllerState.Achievements;
+                    ShowViewController(gameCenterController);
+                }
+            }
+            else
+            {
+                UIAlertView alert = new UIAlertView("Error", "You must be signed in to Game Center to view achievements.", null, "OK");
+                alert.Show();
+                ShowSignIn(1, true);
+            }
+        }
+
+        [CLSCompliant(false)]
+        public static void ShowTwitter(string tweetInitialText = null, string tweetAddUrl = null, UIImage tweetAddImage = null)
+        {
+            AssertInitialised();
+
+            if (Twitter.TWTweetComposeViewController.CanSendTweet)
+            {
+                var tweetController = new Twitter.TWTweetComposeViewController();
+                tweetController.SetCompletionHandler((Twitter.TWTweetComposeViewControllerResult r) =>
+                {
+                    HideViewController(tweetController);
+                });
+
+                if (!String.IsNullOrEmpty(tweetInitialText))
+                    tweetController.SetInitialText(tweetInitialText);
+
+                if (!String.IsNullOrEmpty(tweetAddUrl))
+                    tweetController.AddUrl(NSUrl.FromString(tweetAddUrl));
+
+                if (tweetAddImage != null)
+                    tweetController.AddImage(tweetAddImage);
+
+                ShowViewController(tweetController);
+            }
+            else
+            {
+                UIAlertView alert = new UIAlertView("Error", "There are no Twitter accounts configured on this iOS device.", null, "OK");
+                alert.Show();
+            }
+        }
+
+        [CLSCompliant(false)]
+        public static void ShowPeerPicker(GKPeerPickerControllerDelegate aPeerPickerControllerDelegate)
+        {
+            AssertInitialised();
+
+            if ((Gamer.SignedInGamers.Count > 0) && (Gamer.SignedInGamers[0].IsSignedInToLive))
+            {
+                // Lazy load it
+                if (peerPickerController == null)
+                {
+                    peerPickerController = new GKPeerPickerController();
+                }
+
+                if (peerPickerController != null)
+                {           
+                    peerPickerController.ConnectionTypesMask = GKPeerPickerConnectionType.Nearby;
+                    peerPickerController.Delegate = aPeerPickerControllerDelegate;
+                    peerPickerController.Show();                    
+                }
+            }
+        }
+
+        /// <summary>
+        /// Displays the iOS matchmaker to the player.
+        /// </summary>
+        /// <remarks>
+        /// Note this is not overloaded in derived classes on purpose.  This is
+        /// only a reason this exists is for caching effects.
+        /// </remarks>
+        /// <param name="minPlayers">Minimum players to find</param>
+        /// <param name="maxPlayers">Maximum players to find</param>
+        /// <param name="playersToInvite">Players to invite</param>
+        public static void ShowMatchMaker(int minPlayers, int maxPlayers, string[] playersToInvite)
+        {
+            AssertInitialised();
+
+            if ((Gamer.SignedInGamers.Count > 0) && (Gamer.SignedInGamers[0].IsSignedInToLive))
+            {
+                var matchmakerViewController = new GKMatchmakerViewController(new GKMatchRequest());
+
+                matchmakerViewController.DidFailWithError += delegate(object sender, GKErrorEventArgs e)
+                {
+                    HideViewController(matchmakerViewController);
+                };
+
+                matchmakerViewController.DidFindMatch += delegate(object sender, GKMatchEventArgs e)
+                {
+                    Guide.Match = e.Match;
+                };
+
+                matchmakerViewController.DidFindPlayers += delegate(object sender, GKPlayersEventArgs e)
+                {
+
+                };
+
+                matchmakerViewController.WasCancelled += delegate(object sender, EventArgs e)
+                {
+                    HideViewController(matchmakerViewController);
+                };
+
+                matchmakerViewController.MatchRequest.MinPlayers = minPlayers;
+                matchmakerViewController.MatchRequest.MaxPlayers = maxPlayers;
+                matchmakerViewController.MatchRequest.PlayersToInvite = playersToInvite;
+
+                ShowViewController(matchmakerViewController);
+            }
+        }
+
+        /// <summary>
+        /// Displays the iOS matchmaker to the player.
+        /// </summary>
+        /// <remarks>
+        /// Note this is not overloaded in derived classes on purpose.  This is
+        /// only a reason this exists is for caching effects.
+        /// </remarks>
+        /// <param name="minPlayers">Minimum players to find</param>
+        /// <param name="maxPlayers">Maximum players to find</param>
+        public static void ShowMatchMaker(int minPlayers, int maxPlayers)
+        {
+            //ShowMatchMaker(minPlayers, maxPlayers, null); // Setting playersToInvite to null causes the game to crash (tested on iOS 5+)
+            ShowMatchMaker(minPlayers, maxPlayers, new string[] { });
+        }
+    }
+}
diff --git a/MonoGame.Framework/iOS/GamerServices/KeyboardInputView.cs b/MonoGame.Framework/iOS/GamerServices/KeyboardInputView.cs
new file mode 100644
index 00000000000..e519f5b7eee
--- /dev/null
+++ b/MonoGame.Framework/iOS/GamerServices/KeyboardInputView.cs
@@ -0,0 +1,287 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009-2012 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+1. Definitions
+
+The terms "reproduce," "reproduction," "derivative works," and "distribution"
+have the same meaning here as under U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the
+software.
+
+A "contributor" is any person that distributes its contribution under this
+license.
+
+"Licensed patents" are a contributor's patent claims that read directly on its
+contribution.
+
+2. Grant of Rights
+
+(A) Copyright Grant- Subject to the terms of this license, including the
+license conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free copyright license to reproduce its
+contribution, prepare derivative works of its contribution, and distribute its
+contribution or any derivative works that you create.
+
+(B) Patent Grant- Subject to the terms of this license, including the license
+conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free license under its licensed patents to
+make, have made, use, sell, offer for sale, import, and/or otherwise dispose of
+its contribution in the software or derivative works of the contribution in the
+software.
+
+3. Conditions and Limitations
+
+(A) No Trademark License- This license does not grant you rights to use any
+contributors' name, logo, or trademarks.
+
+(B) If you bring a patent claim against any contributor over patents that you
+claim are infringed by the software, your patent license from such contributor
+to the software ends automatically.
+
+(C) If you distribute any portion of the software, you must retain all
+copyright, patent, trademark, and attribution notices that are present in the
+software.
+
+(D) If you distribute any portion of the software in source code form, you may
+do so only under this license by including a complete copy of this license with
+your distribution. If you distribute any portion of the software in compiled or
+object code form, you may only do so under a license that complies with this
+license.
+
+(E) The software is licensed "as-is." You bear the risk of using it. The
+contributors give no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the contributors exclude
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.
+*/
+
+
+#endregion License
+
+using System;
+using System.Drawing;
+
+using Foundation;
+using UIKit;
+using CoreGraphics;
+
+namespace Microsoft.Xna.Framework {
+	class KeyboardInputView : UIScrollView {
+		private static readonly PaddingF TitleMargin = new PaddingF (10, 7, 10, 2);
+		private static readonly PaddingF DescriptionMargin = new PaddingF (12, 2, 10, 5);
+		private static readonly PaddingF TextFieldMargin = new PaddingF (10, 5, 10, 5);
+
+		private readonly UIToolbar _toolbar;
+		private readonly UILabel _title;
+		private readonly UILabel _description;
+		private readonly UITextField _textField;
+		private readonly UIScrollView _textFieldContainer;
+
+		public KeyboardInputView (RectangleF frame)
+			: base(frame)
+		{
+			_toolbar = new UIToolbar (frame);
+
+			var toolbarItems = new UIBarButtonItem[] {
+				new UIBarButtonItem (UIBarButtonSystemItem.Cancel, CancelButton_Tapped),
+				new UIBarButtonItem (UIBarButtonSystemItem.FlexibleSpace, null),
+				new UIBarButtonItem (UIBarButtonSystemItem.Done, DoneButton_Tapped)
+			};
+
+			_toolbar.SetItems (toolbarItems, false);
+			_toolbar.SizeToFit ();
+
+			_title = new UILabel (RectangleF.Empty);
+			_title.Font = UIFont.SystemFontOfSize (UIFont.LabelFontSize * 1.2f);
+			_title.BackgroundColor = UIColor.Clear;
+			_title.LineBreakMode = UILineBreakMode.TailTruncation;
+			_title.Lines = 2;
+
+			_description = new UILabel (RectangleF.Empty);
+			_description.Font = UIFont.SystemFontOfSize (UIFont.LabelFontSize);
+			_description.TextColor = UIColor.DarkTextColor.ColorWithAlpha (0.95f);
+			_description.BackgroundColor = UIColor.Clear;
+			_title.LineBreakMode = UILineBreakMode.TailTruncation;
+			_description.Lines = 2;
+
+			_textFieldContainer = new UIScrollView(new RectangleF(0, 0, 100, 100));
+
+			_textField = new UITextField (_textFieldContainer.Bounds);
+			_textField.AutoresizingMask =
+				UIViewAutoresizing.FlexibleWidth |
+				UIViewAutoresizing.FlexibleHeight;
+			_textField.BorderStyle = UITextBorderStyle.RoundedRect;
+			_textField.Delegate = new TextFieldDelegate (this);
+
+			_textFieldContainer.Add (_textField);
+
+			Add (_toolbar);
+			Add (_title);
+			Add (_description);
+			Add (_textFieldContainer);
+
+			AutoresizingMask = UIViewAutoresizing.FlexibleWidth | UIViewAutoresizing.FlexibleHeight;
+			AutosizesSubviews = false;
+			Opaque = true;
+			BackgroundColor = UIColor.FromRGB (0xC5, 0xCC, 0xD4);
+
+			SetNeedsLayout ();
+		}
+
+		#region Properties
+
+		public string Title {
+			get { return _title.Text; }
+			set {
+				if (_title.Text != value) {
+					_title.Text = value;
+					SetNeedsLayout ();
+				}
+			}
+		}
+
+        public new string Description {
+			get { return _description.Text; }
+			set {
+				if (_description.Text != value) {
+					_description.Text = value;
+					SetNeedsLayout ();
+				}
+			}
+		}
+
+		public string Text {
+			get { return _textField.Text; }
+			set {
+				if (_textField.Text != value) {
+					_textField.Text = value;
+				}
+			}
+		}
+
+		public bool UsePasswordMode {
+			get { return _textField.SecureTextEntry; }
+			set {
+				if (_textField.SecureTextEntry != value) {
+					_textField.SecureTextEntry = value;
+				}
+			}
+		}
+
+		#endregion Properties
+
+		#region Events
+
+		public event EventHandler<EventArgs> InputAccepted;
+		public event EventHandler<EventArgs> InputCanceled;
+
+		#endregion Events
+
+		public void ActivateFirstField ()
+		{
+			_textField.BecomeFirstResponder ();
+		}
+
+		public void ScrollActiveFieldToVisible ()
+		{
+			if (!_textField.IsFirstResponder)
+				return;
+
+			var bounds = Bounds;
+			bounds.X += ContentInset.Left;
+			bounds.Width -= (ContentInset.Left + ContentInset.Right);
+			bounds.Y += ContentInset.Top;
+			bounds.Height -= (ContentInset.Top + ContentInset.Bottom);
+
+			if (!bounds.Contains(_textFieldContainer.Frame)) {
+				ScrollRectToVisible (_textFieldContainer.Frame, true);
+			}
+		}
+
+		public override void TouchesEnded(NSSet touches, UIEvent evt)
+		{
+			base.TouchesEnded(touches, evt);
+			_textField.ResignFirstResponder ();
+		}
+
+		public override void LayoutSubviews ()
+		{
+			_toolbar.SizeToFit ();
+
+			var titleSize = SizeThatFitsWidth (_title, Bounds.Width - TitleMargin.Horizontal);
+			_title.Frame = new CGRect (
+				TitleMargin.Left, _toolbar.Bounds.Bottom + TitleMargin.Top,
+				titleSize.Width, titleSize.Height);
+
+			var descriptionSize = SizeThatFitsWidth (
+				_description, Bounds.Width - DescriptionMargin.Horizontal);
+			_description.Frame = new CGRect (
+				DescriptionMargin.Left,
+				_title.Frame.Bottom + TitleMargin.Bottom + DescriptionMargin.Top,
+				descriptionSize.Width, descriptionSize.Height);
+
+			var textFieldSize = _textField.SizeThatFits (
+				new CGSize(Bounds.Width - TextFieldMargin.Horizontal, Bounds.Height));
+			_textFieldContainer.Frame = new CGRect (
+				TextFieldMargin.Left,
+				_description.Frame.Bottom + DescriptionMargin.Bottom + TextFieldMargin.Top,
+				Bounds.Width - TextFieldMargin.Horizontal, textFieldSize.Height);
+
+			ContentSize = new CGSize(Bounds.Width, _textFieldContainer.Frame.Bottom + TextFieldMargin.Bottom);
+		}
+
+		private static CGSize SizeThatFitsWidth(UILabel label, nfloat width)
+		{
+			var font = label.Font;
+            return label.SizeThatFits(new CGSize(width, font.LineHeight * label.Lines));
+		}
+
+		private void DoneButton_Tapped (object sender, EventArgs e)
+		{
+			OnInputAccepted (e);
+		}
+
+		private void CancelButton_Tapped (object sender, EventArgs e)
+		{
+			OnInputCanceled (e);
+		}
+
+		private void OnInputAccepted(EventArgs e)
+		{
+			EventHelpers.Raise(this, InputAccepted, e);
+		}
+
+		private void OnInputCanceled(EventArgs e)
+		{
+			EventHelpers.Raise(this, InputCanceled, e);
+		}
+
+		private class TextFieldDelegate : UITextFieldDelegate
+		{
+			private readonly KeyboardInputView _owner;
+			public TextFieldDelegate (KeyboardInputView owner)
+			{
+				if (owner == null)
+					throw new ArgumentNullException ("owner");
+				_owner = owner;
+			}
+
+			public override bool ShouldReturn(UITextField textField)
+			{
+				_owner.OnInputAccepted (EventArgs.Empty);
+				return true;
+			}
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/iOS/GamerServices/KeyboardInputViewController.cs b/MonoGame.Framework/iOS/GamerServices/KeyboardInputViewController.cs
new file mode 100644
index 00000000000..bf885ce77c0
--- /dev/null
+++ b/MonoGame.Framework/iOS/GamerServices/KeyboardInputViewController.cs
@@ -0,0 +1,220 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009-2012 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+1. Definitions
+
+The terms "reproduce," "reproduction," "derivative works," and "distribution"
+have the same meaning here as under U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the
+software.
+
+A "contributor" is any person that distributes its contribution under this
+license.
+
+"Licensed patents" are a contributor's patent claims that read directly on its
+contribution.
+
+2. Grant of Rights
+
+(A) Copyright Grant- Subject to the terms of this license, including the
+license conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free copyright license to reproduce its
+contribution, prepare derivative works of its contribution, and distribute its
+contribution or any derivative works that you create.
+
+(B) Patent Grant- Subject to the terms of this license, including the license
+conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free license under its licensed patents to
+make, have made, use, sell, offer for sale, import, and/or otherwise dispose of
+its contribution in the software or derivative works of the contribution in the
+software.
+
+3. Conditions and Limitations
+
+(A) No Trademark License- This license does not grant you rights to use any
+contributors' name, logo, or trademarks.
+
+(B) If you bring a patent claim against any contributor over patents that you
+claim are infringed by the software, your patent license from such contributor
+to the software ends automatically.
+
+(C) If you distribute any portion of the software, you must retain all
+copyright, patent, trademark, and attribution notices that are present in the
+software.
+
+(D) If you distribute any portion of the software in source code form, you may
+do so only under this license by including a complete copy of this license with
+your distribution. If you distribute any portion of the software in compiled or
+object code form, you may only do so under a license that complies with this
+license.
+
+(E) The software is licensed "as-is." You bear the risk of using it. The
+contributors give no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the contributors exclude
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.
+*/
+#endregion License
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+
+using Foundation;
+using UIKit;
+
+namespace Microsoft.Xna.Framework {
+	class KeyboardInputViewController : UIViewController {
+		private readonly string _titleText;
+		private readonly string _descriptionText;
+		private readonly string _defaultText;
+		private readonly bool _usePasswordMode;
+        private UIViewController _gameViewController;
+
+		public KeyboardInputViewController (
+			string titleText, string descriptionText, string defaultText, bool usePasswordMode, UIViewController gameViewController)
+		{
+			_titleText = titleText;
+			_descriptionText = descriptionText;
+			_defaultText = defaultText;
+			_usePasswordMode = usePasswordMode;
+            _gameViewController = gameViewController;
+		}
+
+		private readonly List<NSObject> _keyboardObservers = new List<NSObject> ();
+		public override void LoadView ()
+		{
+			var view = new KeyboardInputView (new RectangleF (0, 0, 240, 320));
+			view.Title = _titleText;
+			view.Description = _descriptionText;
+			view.Text = _defaultText;
+			view.UsePasswordMode = _usePasswordMode;
+
+			view.ActivateFirstField ();
+
+			base.View = view;
+
+			_keyboardObservers.Add (
+				NSNotificationCenter.DefaultCenter.AddObserver(
+					UIKeyboard.DidShowNotification, Keyboard_DidShow));
+			_keyboardObservers.Add (
+				NSNotificationCenter.DefaultCenter.AddObserver(
+					UIKeyboard.WillHideNotification, Keyboard_WillHide));
+		}
+
+		public new KeyboardInputView View {
+			get { return (KeyboardInputView) base.View; }
+		}
+
+        [Obsolete]
+		public override void ViewDidUnload ()
+		{
+			base.ViewDidUnload ();
+
+			NSNotificationCenter.DefaultCenter.RemoveObservers (_keyboardObservers);
+			_keyboardObservers.Clear ();
+
+            _gameViewController = null;
+		}
+
+		private void Keyboard_DidShow(NSNotification notification)
+		{
+			var keyboardSize = UIKeyboard.FrameBeginFromNotification (notification).Size;
+
+			if (InterfaceOrientation == UIInterfaceOrientation.LandscapeLeft ||
+			    InterfaceOrientation == UIInterfaceOrientation.LandscapeRight)
+            {
+                var tmpkeyboardSize = keyboardSize;
+				keyboardSize.Width = (nfloat)Math.Max(tmpkeyboardSize.Height, tmpkeyboardSize.Width);
+				keyboardSize.Height = (nfloat)Math.Min(tmpkeyboardSize.Height, tmpkeyboardSize.Width);
+			}
+
+			var view = (KeyboardInputView)View;
+			var contentInsets = new UIEdgeInsets(0f, 0f, keyboardSize.Height, 0f);
+			view.ContentInset = contentInsets;
+			view.ScrollIndicatorInsets = contentInsets;
+
+			view.ScrollActiveFieldToVisible ();
+		}
+
+		private void Keyboard_WillHide(NSNotification notification)
+		{
+			var view = (KeyboardInputView)View;
+			view.ContentInset = UIEdgeInsets.Zero;
+			view.ScrollIndicatorInsets = UIEdgeInsets.Zero;
+		}
+
+        #region Autorotation for iOS 5 or older
+        [Obsolete]
+		public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation)
+		{
+            var requestedOrientation = OrientationConverter.ToDisplayOrientation(toInterfaceOrientation);
+            var supportedOrientations = (_gameViewController as iOSGameViewController).SupportedOrientations;
+
+            return (supportedOrientations & requestedOrientation) != 0;
+		}
+        #endregion
+
+        #region Autorotation for iOS 6 or newer
+        public override UIInterfaceOrientationMask GetSupportedInterfaceOrientations ()
+        {
+            return OrientationConverter.ToUIInterfaceOrientationMask((_gameViewController as iOSGameViewController).SupportedOrientations);
+        }
+        
+        public override bool ShouldAutorotate ()
+        {
+            return true;
+        }
+        
+        public override UIInterfaceOrientation PreferredInterfaceOrientationForPresentation ()
+        {
+            return _gameViewController.PreferredInterfaceOrientationForPresentation();
+        }
+        #endregion
+
+		public override void WillRotate(UIInterfaceOrientation toInterfaceOrientation, double duration)
+		{
+			base.WillRotate(toInterfaceOrientation, duration);
+			View.LayoutSubviews ();
+		}
+	}
+
+	struct PaddingF {
+		public float Left;
+		public float Top;
+		public float Right;
+		public float Bottom;
+
+		public float Horizontal {
+			get { return Left + Right; }
+		}
+
+		public float Vertical {
+			get { return Top + Bottom; }
+		}
+
+		public PaddingF (float all)
+		{
+			Left = Top = Right = Bottom = all;
+		}
+
+		public PaddingF (float left, float top, float right, float bottom)
+		{
+			Left = left;
+			Top = top;
+			Right = right;
+			Bottom = bottom;
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/iOS/GamerServices/SignedInGamer.cs b/MonoGame.Framework/iOS/GamerServices/SignedInGamer.cs
new file mode 100644
index 00000000000..0fdc1a30540
--- /dev/null
+++ b/MonoGame.Framework/iOS/GamerServices/SignedInGamer.cs
@@ -0,0 +1,503 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using Foundation;
+using GameKit;
+using UIKit;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    // iOS Unified API needs explicit conversion of DateTime/NSDate
+    // see http://developer.xamarin.com/guides/cross-platform/macios/unified/
+    public static class DateTimeNSDateConversions
+    {
+        public static DateTime NSDateToDateTime(this NSDate date)
+        {
+            DateTime reference = TimeZone.CurrentTimeZone.ToLocalTime( 
+                new DateTime(2001, 1, 1, 0, 0, 0) );
+            return reference.AddSeconds(date.SecondsSinceReferenceDate);
+        }
+
+        public static NSDate DateTimeToNSDate(this DateTime date)
+        {
+            DateTime reference = TimeZone.CurrentTimeZone.ToLocalTime(
+                new DateTime(2001, 1, 1, 0, 0, 0) );
+            return NSDate.FromTimeIntervalSinceReferenceDate(
+                (date - reference).TotalSeconds);
+        }
+    }
+
+    public class SignedInGamer : Gamer
+    {
+        private GKLocalPlayer lp;
+		
+        private AchievementCollection gamerAchievements;
+        private FriendCollection friendCollection;
+
+        delegate void AuthenticationDelegate();
+
+        public IAsyncResult BeginAuthentication(AsyncCallback callback, Object asyncState)
+        {
+            // Go off authenticate
+            AuthenticationDelegate ad = DoAuthentication; 
+			
+            return ad.BeginInvoke(callback, ad);
+        }
+
+        public void EndAuthentication(IAsyncResult result)
+        {
+            AuthenticationDelegate ad = (AuthenticationDelegate)result.AsyncState; 
+			
+            ad.EndInvoke(result);
+        }
+
+        private void DoAuthentication()
+        {
+            try
+            {
+                if (UIDevice.CurrentDevice.CheckSystemVersion(4, 1))
+                {
+                    UIApplication.SharedApplication.BeginInvokeOnMainThread(delegate
+                    {
+                        lp = GKLocalPlayer.LocalPlayer;
+                    
+                        if (lp != null)
+                        {
+                            if (!UIDevice.CurrentDevice.CheckSystemVersion(6, 0))
+                            {
+                                #pragma warning disable 618
+                                // Game Center authentication for iOS 5 and older
+                                lp.Authenticate(delegate(NSError error)
+                                {
+                                    #if DEBUG
+                                    if (error != null)
+                                        Console.WriteLine(error);
+                                    #endif
+                                });
+                                #pragma warning restore 618
+                            }
+                            else
+                            {
+                                // Game Center authentication for iOS 6+
+                                lp.AuthenticateHandler = delegate(UIViewController controller, NSError error)
+                                {
+                                    #if DEBUG
+                                    if (error != null)
+                                        Console.WriteLine(error);
+                                    #endif
+
+                                    if (controller != null)
+                                        ((UIViewController)Game.Instance.Services.GetService(typeof(UIViewController))).PresentViewController(controller, true, null);
+                                };
+                            }
+                        }
+                    });
+                }
+            }
+            #if DEBUG
+            catch (Exception e)
+            {
+                Console.WriteLine(e.Message);
+            }
+            #else
+            catch
+            {
+            }
+            #endif
+        }
+
+        public SignedInGamer()
+        {
+            // Register to receive the GKPlayerAuthenticationDidChangeNotificationName so we are notified when authentication changes
+            NSNotificationCenter.DefaultCenter.AddObserver(new NSString("GKPlayerAuthenticationDidChangeNotificationName"), (notification) =>
+            {   
+                if (lp != null && lp.Authenticated)
+                {
+                    this.Gamertag = lp.Alias;
+                    this.DisplayName = lp.PlayerID;	
+                    // Insert code here to handle a successful authentication.
+                    Gamer.SignedInGamers.Add(this);
+                    // Fire the SignedIn event
+                    OnSignedIn(new SignedInEventArgs(this));
+                }
+                else
+                {
+                    // Insert code here to clean up any outstanding Game Center-related classes.
+                    Gamer.SignedInGamers.Remove(this);
+                    // Fire the SignedOut event
+                    OnSignedOut(new SignedOutEventArgs(this));
+                }
+            });
+			
+            var result = BeginAuthentication(null, null);	
+            EndAuthentication(result);
+        }
+
+        private void AuthenticationCompletedCallback(IAsyncResult result)
+        {
+            EndAuthentication(result);	
+        }
+
+        #region Methods
+        public FriendCollection GetFriends()
+        {
+            if (IsSignedInToLive)
+            {
+                if (friendCollection == null)
+                {
+                    friendCollection = new FriendCollection();
+                }
+				
+                lp.LoadFriends(delegate (string[] FriendsList, NSError error)
+                {
+                    foreach (string Friend in FriendsList)
+                    {
+                        friendCollection.Add(new FriendGamer(){ Gamertag = Friend });
+                    }
+                });
+            }
+			
+            return friendCollection;
+        }
+
+        public bool IsFriend(Gamer gamer)
+        {
+            if (gamer == null)
+                throw new ArgumentNullException();
+			
+            if (gamer.IsDisposed)
+                throw new ObjectDisposedException(gamer.ToString());	
+			
+            bool found = false;
+            foreach (FriendGamer f in friendCollection)
+            {
+                if (f.Gamertag == gamer.Gamertag)
+                {
+                    found = true;
+                }
+            }
+            return found;
+						
+        }
+
+        delegate AchievementCollection GetAchievementsDelegate();
+
+        public IAsyncResult BeginGetAchievements(AsyncCallback callback, Object asyncState)
+        {
+            // Go off and grab achievements
+            GetAchievementsDelegate gad = GetAchievements; 
+			
+            return gad.BeginInvoke(callback, gad);
+        }
+
+        private void GetAchievementCompletedCallback(IAsyncResult result)
+        {
+            // get the delegate that was used to call that method
+            GetAchievementsDelegate gad = (GetAchievementsDelegate)result.AsyncState; 
+
+            // get the return value from that method call
+            gamerAchievements = gad.EndInvoke(result);
+        }
+
+        public AchievementCollection EndGetAchievements(IAsyncResult result)
+        {
+            GetAchievementsDelegate gad = (GetAchievementsDelegate)result.AsyncState; 
+			
+            gamerAchievements = gad.EndInvoke(result);
+			
+            return gamerAchievements;
+        }
+
+        public AchievementCollection GetAchievements()
+        {
+            if (IsSignedInToLive)
+            {
+                if (gamerAchievements == null)
+                {
+                    gamerAchievements = new AchievementCollection();
+                }
+				
+                GKAchievementDescription.LoadAchievementDescriptions(delegate(GKAchievementDescription[] achievements, NSError error)
+                {
+                    if (achievements != null)
+                    {
+                        foreach (GKAchievementDescription a in achievements)
+                        {
+                            gamerAchievements.Add(new Achievement() {
+                                Name = a.Title,
+                                Key = a.Identifier,
+                                Description = a.AchievedDescription,
+                                HowToEarn = a.UnachievedDescription,
+                                DisplayBeforeEarned = !a.Hidden
+                            });
+                        }
+                    }
+                });
+				
+                GKAchievement.LoadAchievements(delegate(GKAchievement[] achievements, NSError error)
+                {
+                    if (achievements != null)
+                    {
+                        foreach (GKAchievement a in achievements)
+                        {
+                            foreach (Achievement ac in gamerAchievements)
+                            {
+                                if (ac.Key == a.Identifier)
+                                {
+                                    ac.IsEarned = a.Completed;
+                                    ac.EarnedDateTime = a.LastReportedDate.NSDateToDateTime();
+                                }
+                            }															
+                        }
+                    }
+                });
+            }
+            return gamerAchievements;
+        }
+
+        delegate void AwardAchievementDelegate(string achievementId, double percentageComplete);
+
+        public IAsyncResult BeginAwardAchievement(string achievementId, AsyncCallback callback, Object state)
+        {
+            return BeginAwardAchievement(achievementId, 100.0, callback, state);
+        }
+
+        public IAsyncResult BeginAwardAchievement(
+            string achievementId,
+            double percentageComplete,
+            AsyncCallback callback,
+            Object state
+        )
+        {	
+            // Go off and award the achievement
+            AwardAchievementDelegate aad = DoAwardAchievement; 
+				
+            return aad.BeginInvoke(achievementId, percentageComplete, callback, aad);
+        }
+
+        public void EndAwardAchievement(IAsyncResult result)
+        {
+            AwardAchievementDelegate aad = (AwardAchievementDelegate)result.AsyncState; 
+			
+            aad.EndInvoke(result);
+        }
+
+        private void AwardAchievementCompletedCallback(IAsyncResult result)
+        {
+            EndAwardAchievement(result);	
+        }
+
+        public void AwardAchievement(string achievementId)
+        {			
+            AwardAchievement(achievementId, 100.0f);
+        }
+
+        public void DoAwardAchievement(string achievementId, double percentageComplete)
+        {
+            if (IsSignedInToLive)
+            {
+                UIApplication.SharedApplication.InvokeOnMainThread(delegate
+                {
+                    GKAchievement achievement = new GKAchievement(achievementId);
+                    achievement.PercentComplete = percentageComplete;
+
+                    if (!UIDevice.CurrentDevice.CheckSystemVersion(6, 0))
+                    {
+                        #pragma warning disable 618
+                        // Report achievement for iOS 5 and older
+                        achievement.ReportAchievement(delegate(NSError error)
+                        {
+                            if (error != null)
+                            {
+                                // Oh oh something went wrong.
+                            }
+                        });
+                        #pragma warning restore 618
+                    }
+                    else
+                    {
+                        // Report achievement for iOS 6+
+                        GKAchievement.ReportAchievements(new GKAchievement[] { achievement }, delegate (NSError error)
+                        {
+                            if (error != null)
+                            {
+                                // Oh oh something went wrong.
+                            }
+                        });
+                    }
+                });
+            }
+        }
+
+        public void AwardAchievement(string achievementId, double percentageComplete)
+        {
+            if (IsSignedInToLive)
+            {
+                BeginAwardAchievement(achievementId, percentageComplete, AwardAchievementCompletedCallback, null);
+            }
+        }
+
+        public void UpdateScore(string aCategory, long aScore)
+        {
+            if (IsSignedInToLive)
+            {
+                UIApplication.SharedApplication.InvokeOnMainThread(delegate
+                {
+                    GKScore score = new GKScore(aCategory);
+                    score.Value = aScore;
+
+                    if (!UIDevice.CurrentDevice.CheckSystemVersion(6, 0))
+                    {
+                        #pragma warning disable 618
+                        // Report score for iOS 5 and older
+                        score.ReportScore(delegate (NSError error)
+                        {
+                            if (error != null)
+                            {
+                                // Oh oh something went wrong.
+                            }
+                        });
+                        #pragma warning restore 618
+                    }
+                    else
+                    {
+                        // Report score for iOS 6+
+                        GKScore.ReportScores(new GKScore[] { score }, delegate (NSError error)
+                        {
+                            if (error != null)
+                            {
+                                // Oh oh something went wrong.
+                            }
+                        });
+                    }
+                });
+            }
+        }
+
+        public void ResetAchievements()
+        {
+            if (IsSignedInToLive)
+            {
+                UIApplication.SharedApplication.InvokeOnMainThread(delegate
+                {
+                    GKAchievement.ResetAchivements(delegate(NSError error)
+                    {
+                        if (error != null)
+                        {
+                            // Oh oh something went wrong.
+                        }
+                    });
+                });
+            }
+        }
+        #endregion
+
+        #region Properties
+        public GameDefaults GameDefaults
+        { 
+            get
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        public bool IsGuest
+        { 
+            get
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        public bool IsSignedInToLive
+        { 
+            get
+            {
+                var SignedIn = ((lp != null) && (lp.Authenticated));
+                return SignedIn;
+            }
+        }
+
+        public int PartySize
+        { 
+            get
+            {
+                throw new NotSupportedException();
+            }
+            set
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        public PlayerIndex PlayerIndex
+        {
+            get
+            {
+                return PlayerIndex.One;
+            }
+        }
+
+        public GamerPresence Presence
+        { 
+            get
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        GamerPrivileges _privileges = new GamerPrivileges();
+
+        public GamerPrivileges Privileges
+        {
+            get
+            {
+                return _privileges;
+            }
+        }
+
+        //        LeaderboardWriter _leaderboardWriter = new LeaderboardWriter();
+        //        public LeaderboardWriter LeaderboardWriter
+        //        {
+        //            get
+        //            {
+        //                return _leaderboardWriter;
+        //            }
+        //        }
+        #endregion
+		
+        protected virtual void OnSignedIn(SignedInEventArgs e)
+        {
+            EventHelpers.Raise(this, SignedIn, e);
+        }
+
+        protected virtual void OnSignedOut(SignedOutEventArgs e)
+        {
+            EventHelpers.Raise(this, SignedOut, e);
+        }
+
+		
+        #region Events
+        public static event EventHandler<SignedInEventArgs> SignedIn;
+        public static event EventHandler<SignedOutEventArgs> SignedOut;
+        #endregion
+    }
+
+    public class SignedInEventArgs : EventArgs
+    {
+        public SignedInEventArgs(SignedInGamer gamer)
+        {
+			
+        }
+    }
+
+    public class SignedOutEventArgs : EventArgs
+    {
+        public SignedOutEventArgs(SignedInGamer gamer)
+        {
+			
+        }
+    }
+}
diff --git a/MonoGame.Framework/iOS/GamerServices/TextFieldAlertView.cs b/MonoGame.Framework/iOS/GamerServices/TextFieldAlertView.cs
new file mode 100644
index 00000000000..eb069c3c986
--- /dev/null
+++ b/MonoGame.Framework/iOS/GamerServices/TextFieldAlertView.cs
@@ -0,0 +1,116 @@
+using System;
+using System.Drawing;
+
+using Foundation;
+using UIKit;
+using CoreGraphics;
+
+namespace Microsoft.Xna.Framework.GamerServices
+{
+    [CLSCompliant(false)]
+	public class TextFieldAlertView : UIAlertView
+	{
+		private UITextField _tf = null;
+		private bool _secureTextEntry;
+		
+		private string _initEditValue;
+		private string _placeHolderValue;
+		
+		public TextFieldAlertView() : this(false) {}
+		
+        [CLSCompliant(false)]
+		public TextFieldAlertView(bool secureTextEntry, string title, string message, UIAlertViewDelegate alertViewDelegate, string cancelBtnTitle, params string[] otherButtons)
+			: base(title, message, alertViewDelegate, cancelBtnTitle, otherButtons)
+		{
+			InitializeControl(secureTextEntry);
+		}
+		
+		public TextFieldAlertView(bool secureTextEntry)
+		{	
+			InitializeControl(secureTextEntry);
+		}
+		
+		public TextFieldAlertView(bool secureTextEntry, string initEditValue, string placeHolderValue )
+		{	
+			InitializeControl(secureTextEntry);
+			_initEditValue = initEditValue;
+			_placeHolderValue = placeHolderValue;
+		}
+		
+		private void InitializeControl(bool secureTextEntry)
+		{
+			_secureTextEntry = secureTextEntry;
+			this.AddButton("Cancel");
+			this.AddButton("Ok");
+			
+			// build out the text field
+			_tf = ComposeTextFieldControl(_secureTextEntry);
+			
+			// add the text field to the alert view
+			this.AddSubview(_tf);
+		}
+		
+		public string EnteredText 
+		{ 
+			get 
+			{ 
+				return _tf.Text; 
+			} 
+		}
+		
+		public override void LayoutSubviews ()
+		{
+			// layout the stock UIAlertView control
+			base.LayoutSubviews ();
+			
+			// We can only force it to become a First Responder after it has been added to the MainView.
+			_tf.BecomeFirstResponder();
+		}
+
+		private UITextField ComposeTextFieldControl(bool secureTextEntry)
+		{
+			UITextField textField = new UITextField (new System.Drawing.RectangleF(12f, 45f, 260f, 25f));
+			textField.BackgroundColor = UIColor.White;
+			textField.UserInteractionEnabled = true;
+			textField.AutocorrectionType = UITextAutocorrectionType.No;
+			textField.AutocapitalizationType = UITextAutocapitalizationType.None;
+			textField.ReturnKeyType = UIReturnKeyType.Done;
+			textField.SecureTextEntry = secureTextEntry;
+			
+			textField.Text = _initEditValue;
+			textField.Placeholder = _placeHolderValue;
+			textField.BecomeFirstResponder();
+			return textField;
+		}
+		
+		public override void Show ()
+		{
+			base.Show ();
+			
+			// shift the contents of the alert view around to accomodate the extra text field
+			this.AdjustControlSize();
+		}
+		
+		private void AdjustControlSize()
+		{
+			nfloat tfExtH = _tf.Frame.Size.Height + 16.0f;
+			
+			CGRect frame = new CGRect(this.Frame.X, 
+			                                  this.Frame.Y - tfExtH/2,
+			                                  this.Frame.Size.Width,
+			                                  this.Frame.Size.Height + tfExtH);
+			this.Frame = frame;
+			
+			foreach(var view in this.Subviews)
+			{
+				if(view is UIControl)
+				{
+					view.Frame = new CGRect(view.Frame.X, 
+					                            view.Frame.Y + tfExtH,
+					                            view.Frame.Size.Width, 
+					                            view.Frame.Size.Height);
+				}
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/MonoGame.Framework/iOS/Net/MonoGamePeerPickerControllerDelegate.cs b/MonoGame.Framework/iOS/Net/MonoGamePeerPickerControllerDelegate.cs
new file mode 100644
index 00000000000..d15606ac383
--- /dev/null
+++ b/MonoGame.Framework/iOS/Net/MonoGamePeerPickerControllerDelegate.cs
@@ -0,0 +1,122 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+#region Using clause
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+using UIKit;
+using GameKit;
+
+using Microsoft.Xna.Framework.GamerServices;
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+    [CLSCompliant(false)]
+	public class MonoGamePeerPickerControllerDelegate : GameKit.GKPeerPickerControllerDelegate
+	{
+		private GKSession gkSession;
+		private EventHandler<GKDataReceivedEventArgs> receivedData;
+		
+        [CLSCompliant(false)]
+		public MonoGamePeerPickerControllerDelegate( GKSession aSession, EventHandler<GKDataReceivedEventArgs> aReceivedData )
+		{
+			gkSession = aSession;
+			receivedData = aReceivedData;
+		}
+		
+        [CLSCompliant(false)]
+		public override void ConnectionTypeSelected(GKPeerPickerController picker, GKPeerPickerConnectionType type)
+		{
+#if DEBUG			
+			Console.WriteLine( "User Selected a ConnectionType of : " + type);
+#endif
+			if (type == GKPeerPickerConnectionType.Online) 
+			{
+
+        		picker.Dismiss();
+				picker.Delegate = null;
+
+       			// Implement your own internet user interface here.
+
+    		}
+		}
+		
+		/*public override GKSession GetSession(GKPeerPickerController picker, GKPeerPickerConnectionType forType)
+		{		
+			Console.WriteLine( "GetSession" );
+			
+			return gkSession;
+		}*/
+        [CLSCompliant(false)]
+		public override void PeerConnected(GKPeerPickerController picker, string peerId, GKSession toSession)		
+		{
+#if DEBUG			
+			Console.WriteLine( "Peer ID " + peerId + " Connected to Session ID : " + toSession.SessionID );
+#endif
+			
+			// Use a retaining property to take ownership of the session.
+    		this.gkSession = toSession;
+
+			// Assumes our object will also become the session's delegate.
+    		gkSession.Delegate = new MonoGameSessionDelegate();
+			gkSession.ReceiveData += new EventHandler<GKDataReceivedEventArgs>(receivedData);
+
+    		picker.Dismiss();
+			
+			// Remove the picker.
+			picker.Delegate = null;
+
+			// Start your game.
+			
+		}
+		
+        [CLSCompliant(false)]
+		public override void ControllerCancelled(GKPeerPickerController picker)
+		{
+#if DEBUG
+			Console.WriteLine( "ControllerCancelled");
+#endif
+			picker.Delegate = null;
+		}
+	}
+}
diff --git a/MonoGame.Framework/iOS/Net/MonoGameSessionDelegate.cs b/MonoGame.Framework/iOS/Net/MonoGameSessionDelegate.cs
new file mode 100644
index 00000000000..9e7ae6881c9
--- /dev/null
+++ b/MonoGame.Framework/iOS/Net/MonoGameSessionDelegate.cs
@@ -0,0 +1,108 @@
+#region License
+// /*
+// Microsoft Public License (Ms-PL)
+// MonoGame - Copyright © 2009 The MonoGame Team
+// 
+// All rights reserved.
+// 
+// This license governs use of the accompanying software. If you use the software, you accept this license. If you do not
+// accept the license, do not use the software.
+// 
+// 1. Definitions
+// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under 
+// U.S. copyright law.
+// 
+// A "contribution" is the original software, or any additions or changes to the software.
+// A "contributor" is any person that distributes its contribution under this license.
+// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+// 
+// 2. Grant of Rights
+// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
+// each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+// 
+// 3. Conditions and Limitations
+// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+// your patent license from such contributor to the software ends automatically.
+// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution 
+// notices that are present in the software.
+// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including 
+// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object 
+// code form, you may only do so under a license that complies with this license.
+// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees
+// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent
+// permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular
+// purpose and non-infringement.
+// */
+#endregion License
+
+#region Using clause
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+using Foundation;
+using UIKit;
+using GameKit;
+
+using Microsoft.Xna.Framework.GamerServices;
+#endregion Using clause
+
+namespace Microsoft.Xna.Framework.Net
+{
+
+    [CLSCompliant(false)]
+	public class MonoGameSessionDelegate : GKSessionDelegate
+	{
+		List<LocalNetworkGamer> gamerList;
+		public override void PeerChangedState(GKSession session, string peerID, GKPeerConnectionState state)
+		{
+			LocalNetworkGamer lng = new LocalNetworkGamer();
+			
+			switch (state)
+            {
+				case GKPeerConnectionState.Available :
+					break;
+				case GKPeerConnectionState.Connected :			    
+				    if ( !gamerList.Contains(lng) )
+					{
+						gamerList.Add(lng);
+					}
+					break;
+				case GKPeerConnectionState.Connecting :
+					break;
+				case GKPeerConnectionState.Disconnected :
+				    if ( gamerList.Contains(lng) )
+					{
+						gamerList.Remove(lng);
+					}
+					break;
+				case GKPeerConnectionState.Unavailable :
+					break;
+			}
+		}
+
+		public override void PeerConnectionRequest(GKSession session, string peerID)
+		{
+#if DEBUG			
+			Console.WriteLine( " Session : " + session.SessionID + " PeerID : " + peerID );
+#endif
+		}
+
+		public override void PeerConnectionFailed(GKSession session, string peerID, NSError error)
+		{
+#if DEBUG			
+			Console.WriteLine( " Session : " + session.SessionID + " PeerID : " + peerID +" PeerConnectionFailed : " + error );
+#endif
+		}
+
+		public override void FailedWithError(GKSession session, NSError error)
+		{
+#if DEBUG
+			Console.WriteLine( " Session : " + session.SessionID + " FailedWithError : " + error );
+#endif
+		}
+	}
+}
diff --git a/MonoGame.Framework/iOS/OrientationConverter.cs b/MonoGame.Framework/iOS/OrientationConverter.cs
new file mode 100644
index 00000000000..e41ede95d9a
--- /dev/null
+++ b/MonoGame.Framework/iOS/OrientationConverter.cs
@@ -0,0 +1,147 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009-2011 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+1. Definitions
+
+The terms "reproduce," "reproduction," "derivative works," and "distribution"
+have the same meaning here as under U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the
+software.
+
+A "contributor" is any person that distributes its contribution under this
+license.
+
+"Licensed patents" are a contributor's patent claims that read directly on its
+contribution.
+
+2. Grant of Rights
+
+(A) Copyright Grant- Subject to the terms of this license, including the
+license conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free copyright license to reproduce its
+contribution, prepare derivative works of its contribution, and distribute its
+contribution or any derivative works that you create.
+
+(B) Patent Grant- Subject to the terms of this license, including the license
+conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free license under its licensed patents to
+make, have made, use, sell, offer for sale, import, and/or otherwise dispose of
+its contribution in the software or derivative works of the contribution in the
+software.
+
+3. Conditions and Limitations
+
+(A) No Trademark License- This license does not grant you rights to use any
+contributors' name, logo, or trademarks.
+
+(B) If you bring a patent claim against any contributor over patents that you
+claim are infringed by the software, your patent license from such contributor
+to the software ends automatically.
+
+(C) If you distribute any portion of the software, you must retain all
+copyright, patent, trademark, and attribution notices that are present in the
+software.
+
+(D) If you distribute any portion of the software in source code form, you may
+do so only under this license by including a complete copy of this license with
+your distribution. If you distribute any portion of the software in compiled or
+object code form, you may only do so under a license that complies with this
+license.
+
+(E) The software is licensed "as-is." You bear the risk of using it. The
+contributors give no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the contributors exclude
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.
+*/
+#endregion
+
+using System;
+using UIKit;
+
+namespace Microsoft.Xna.Framework
+{
+    public static class OrientationConverter
+    {
+        [CLSCompliant(false)]
+        public static DisplayOrientation UIDeviceOrientationToDisplayOrientation(UIDeviceOrientation orientation)
+        {
+            switch (orientation)
+            {
+            case UIDeviceOrientation.FaceDown: return DisplayOrientation.Unknown;
+            case UIDeviceOrientation.FaceUp: return DisplayOrientation.Unknown;
+            default:
+			// NOTE: in XNA, Orientation Left is a 90 degree rotation counterclockwise, while on iOS
+			// it is a 90 degree rotation CLOCKWISE. They are BACKWARDS! 
+            case UIDeviceOrientation.LandscapeLeft: return DisplayOrientation.LandscapeRight;
+            case UIDeviceOrientation.LandscapeRight: return DisplayOrientation.LandscapeLeft;
+            case UIDeviceOrientation.Portrait: return DisplayOrientation.Portrait;
+            case UIDeviceOrientation.PortraitUpsideDown: return DisplayOrientation.PortraitDown;
+            }
+        }
+
+        [CLSCompliant(false)]
+        public static DisplayOrientation ToDisplayOrientation(UIInterfaceOrientation orientation)
+        {
+            switch (orientation)
+            {
+            default:
+			// NOTE: in XNA, Orientation Left is a 90 degree rotation counterclockwise, while on iOS
+			// it is a 90 degree rotation CLOCKWISE. They are BACKWARDS! 
+            case UIInterfaceOrientation.LandscapeLeft: return DisplayOrientation.LandscapeRight;
+            case UIInterfaceOrientation.LandscapeRight: return DisplayOrientation.LandscapeLeft;
+            case UIInterfaceOrientation.Portrait: return DisplayOrientation.Portrait;
+            case UIInterfaceOrientation.PortraitUpsideDown: return DisplayOrientation.PortraitDown;
+            }
+        }
+
+        [CLSCompliant(false)]
+        public static UIInterfaceOrientationMask ToUIInterfaceOrientationMask (DisplayOrientation orientation)
+        {
+            switch (Normalize(orientation))
+            {
+                case((DisplayOrientation)0):
+                case((DisplayOrientation)3):
+                    return UIInterfaceOrientationMask.Landscape;
+                // NOTE: in XNA, Orientation Left is a 90 degree rotation counterclockwise, while on iOS
+		// it is a 90 degree rotation CLOCKWISE. They are BACKWARDS! 
+                case((DisplayOrientation)2):
+                    return UIInterfaceOrientationMask.LandscapeLeft;
+                case((DisplayOrientation)1):
+                    return UIInterfaceOrientationMask.LandscapeRight;
+                case((DisplayOrientation)4):
+                    return UIInterfaceOrientationMask.Portrait;
+                case((DisplayOrientation)8):
+                    return UIInterfaceOrientationMask.PortraitUpsideDown;
+                case((DisplayOrientation)7):
+                    return UIInterfaceOrientationMask.AllButUpsideDown;
+                default:
+                    return UIInterfaceOrientationMask.All;
+            }
+        }
+
+        public static DisplayOrientation Normalize(DisplayOrientation orientation)
+        {
+            var normalized = orientation;
+			
+			// Xna's "default" displayorientation is Landscape Left/Right.
+            if (normalized == DisplayOrientation.Default)
+            {
+                normalized |= DisplayOrientation.LandscapeLeft;
+				normalized |= DisplayOrientation.LandscapeRight;
+                normalized &= ~DisplayOrientation.Default;
+            }
+            return normalized;
+        }
+    }
+}
diff --git a/MonoGame.Framework/iOS/iOSGamePlatform.cs b/MonoGame.Framework/iOS/iOSGamePlatform.cs
new file mode 100644
index 00000000000..ee34aa988e7
--- /dev/null
+++ b/MonoGame.Framework/iOS/iOSGamePlatform.cs
@@ -0,0 +1,368 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009-2011 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+1. Definitions
+
+The terms "reproduce," "reproduction," "derivative works," and "distribution"
+have the same meaning here as under U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the
+software.
+
+A "contributor" is any person that distributes its contribution under this
+license.
+
+"Licensed patents" are a contributor's patent claims that read directly on its
+contribution.
+
+2. Grant of Rights
+
+(A) Copyright Grant- Subject to the terms of this license, including the
+license conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free copyright license to reproduce its
+contribution, prepare derivative works of its contribution, and distribute its
+contribution or any derivative works that you create.
+
+(B) Patent Grant- Subject to the terms of this license, including the license
+conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free license under its licensed patents to
+make, have made, use, sell, offer for sale, import, and/or otherwise dispose of
+its contribution in the software or derivative works of the contribution in the
+software.
+
+3. Conditions and Limitations
+
+(A) No Trademark License- This license does not grant you rights to use any
+contributors' name, logo, or trademarks.
+
+(B) If you bring a patent claim against any contributor over patents that you
+claim are infringed by the software, your patent license from such contributor
+to the software ends automatically.
+
+(C) If you distribute any portion of the software, you must retain all
+copyright, patent, trademark, and attribution notices that are present in the
+software.
+
+(D) If you distribute any portion of the software in source code form, you may
+do so only under this license by including a complete copy of this license with
+your distribution. If you distribute any portion of the software in compiled or
+object code form, you may only do so under a license that complies with this
+license.
+
+(E) The software is licensed "as-is." You bear the risk of using it. The
+contributors give no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the contributors exclude
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.
+*/
+#endregion License
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+using Foundation;
+using OpenGLES;
+using UIKit;
+using CoreAnimation;
+using ObjCRuntime;
+
+using Microsoft.Xna.Framework.Audio;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+using Microsoft.Xna.Framework.Input.Touch;
+//using Microsoft.Xna.Framework.GamerServices;
+
+namespace Microsoft.Xna.Framework
+{
+    class iOSGamePlatform : GamePlatform
+    {
+        private iOSGameViewController _viewController;
+        private UIWindow _mainWindow;
+        private List<NSObject> _applicationObservers;
+        private CADisplayLink _displayLink;
+
+        public iOSGamePlatform(Game game) :
+            base(game)
+        {
+            game.Services.AddService(typeof(iOSGamePlatform), this);
+
+            //This also runs the TitleContainer static constructor, ensuring it is done on the main thread
+            Directory.SetCurrentDirectory(TitleContainer.Location);
+
+            _applicationObservers = new List<NSObject>();
+
+            #if !TVOS
+            UIApplication.SharedApplication.SetStatusBarHidden(true, UIStatusBarAnimation.Fade);
+            #endif
+
+            // Create a full-screen window
+            _mainWindow = new UIWindow (UIScreen.MainScreen.Bounds);
+			//_mainWindow.AutoresizingMask = UIViewAutoresizing.FlexibleDimensions;
+			
+            game.Services.AddService (typeof(UIWindow), _mainWindow);
+
+            _viewController = new iOSGameViewController(this);
+            game.Services.AddService (typeof(UIViewController), _viewController);
+            Window = new iOSGameWindow (_viewController);
+
+            _mainWindow.Add (_viewController.View);
+
+            _viewController.InterfaceOrientationChanged += ViewController_InterfaceOrientationChanged;
+
+            //(SJ) Why is this called here when it's not in any other project
+            //Guide.Initialise(game);
+        }
+
+        public override void TargetElapsedTimeChanged ()
+        {
+            CreateDisplayLink();
+        }
+
+        private void CreateDisplayLink()
+        {
+            if (_displayLink != null)
+                _displayLink.RemoveFromRunLoop(NSRunLoop.Main, NSRunLoop.NSDefaultRunLoopMode);
+
+            _displayLink = UIScreen.MainScreen.CreateDisplayLink(_viewController.View as iOSGameView, new Selector("doTick"));
+
+            // FrameInterval represents how many frames must pass before the selector
+            // is called again. We calculate this by dividing our target elapsed time by
+            // the duration of a frame on iOS (Which is 1/60.0f at the time of writing this).
+            _displayLink.FrameInterval = (int)Math.Round(60f * Game.TargetElapsedTime.TotalSeconds);
+
+            _displayLink.AddToRunLoop(NSRunLoop.Main, NSRunLoop.NSDefaultRunLoopMode);
+        }
+
+
+        public override GameRunBehavior DefaultRunBehavior
+        {
+            get { return GameRunBehavior.Asynchronous; }
+        }
+
+        [Obsolete(
+            "iOSGamePlatform.IsPlayingVideo must be removed when MonoGame " +
+            "fully implements the XNA VideoPlayer contract.")]
+        public bool IsPlayingVideo { get; set; }
+
+        // FIXME: VideoPlayer 'needs' this to set up its own movie player view
+        //        controller.
+        public iOSGameViewController ViewController
+        {
+            get { return _viewController; }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            base.Dispose(disposing);
+            if (disposing)
+            {
+                if (_viewController != null)
+                {
+                    _viewController.View.RemoveFromSuperview ();
+                    _viewController.RemoveFromParentViewController ();
+                    _viewController.Dispose();
+                    _viewController = null;
+                }
+
+                if (_mainWindow != null)
+                {
+                    _mainWindow.Dispose();
+                    _mainWindow = null;
+                }
+            }
+        }
+
+        public override void BeforeInitialize()
+        {
+            base.BeforeInitialize ();
+
+            _viewController.View.LayoutSubviews();
+        }
+
+        public override void RunLoop()
+        {
+            throw new NotSupportedException("The iOS platform does not support synchronous run loops");
+        }
+
+        public override void StartRunLoop()
+        {
+            // Show the window
+            _mainWindow.MakeKeyAndVisible();
+
+            // In iOS 8+ we need to set the root view controller *after* Window MakeKey
+            // This ensures that the viewController's supported interface orientations
+            // will be respected at launch
+            _mainWindow.RootViewController = _viewController;
+
+            BeginObservingUIApplication();
+
+            _viewController.View.BecomeFirstResponder();
+            CreateDisplayLink();
+        }
+
+        internal void Tick()
+        {
+            if (!Game.IsActive)
+                return;
+
+            if (IsPlayingVideo)
+                return;
+
+            // FIXME: Remove this call, and the whole Tick method, once
+            //        GraphicsDevice is where platform-specific Present
+            //        functionality is actually implemented.  At that
+            //        point, it should be possible to pass Game.Tick
+            //        directly to NSTimer.CreateRepeatingTimer.
+            _viewController.View.MakeCurrent();
+            Game.Tick ();
+
+            if (!IsPlayingVideo)
+            {
+                if (Game.GraphicsDevice != null)
+                {
+                    // GraphicsDevice.Present() takes care of actually 
+                    // disposing resources disposed from a non-ui thread
+                    Game.GraphicsDevice.Present();
+                }
+                _viewController.View.Present ();
+            }
+        }
+
+        public override bool BeforeDraw(GameTime gameTime)
+        {
+            if (IsPlayingVideo)
+                return false;
+
+            return true;
+        }
+
+        public override bool BeforeUpdate(GameTime gameTime)
+        {
+            if (IsPlayingVideo)
+                return false;
+
+            return true;
+        }
+
+        public override void EnterFullScreen()
+        {
+            // Do nothing: iOS games are always full screen
+        }
+
+        public override void ExitFullScreen()
+        {
+            // Do nothing: iOS games are always full screen
+        }
+
+        public override void Exit()
+        {
+            // Do Nothing: iOS games do not "exit" or shut down.
+        }
+
+        private void BeginObservingUIApplication()
+        {
+            var events = new Tuple<NSString, Action<NSNotification>>[]
+            {
+                Tuple.Create(
+                    UIApplication.DidBecomeActiveNotification,
+                    new Action<NSNotification>(Application_DidBecomeActive)),
+                Tuple.Create(
+                    UIApplication.WillResignActiveNotification,
+                    new Action<NSNotification>(Application_WillResignActive)),
+                Tuple.Create(
+                    UIApplication.WillTerminateNotification,
+                    new Action<NSNotification>(Application_WillTerminate)),
+             };
+
+            foreach (var entry in events)
+                _applicationObservers.Add(NSNotificationCenter.DefaultCenter.AddObserver(entry.Item1, entry.Item2));
+        }
+
+        #region Notification Handling
+
+        private void Application_DidBecomeActive(NSNotification notification)
+        {
+            IsActive = true;
+            #if TVOS
+            _viewController.ControllerUserInteractionEnabled = false;
+            #endif
+            //TouchPanel.Reset();
+        }
+
+        private void Application_WillResignActive(NSNotification notification)
+        {
+            IsActive = false;
+        }
+
+        private void Application_WillTerminate(NSNotification notification)
+        {
+            // FIXME: Cleanly end the run loop.
+			if ( Game != null )
+			{
+				// TODO MonoGameGame.Terminate();
+			}
+        }
+
+        #endregion Notification Handling
+
+        #region Helper Property
+
+        private DisplayOrientation CurrentOrientation {
+            get {
+                #if TVOS
+                return DisplayOrientation.LandscapeLeft;
+                #else
+                return OrientationConverter.ToDisplayOrientation(_viewController.InterfaceOrientation);
+                #endif
+            }
+        }
+
+        #endregion
+
+		private void ViewController_InterfaceOrientationChanged (object sender, EventArgs e)
+		{
+			var orientation = CurrentOrientation;
+
+			// FIXME: The presentation parameters for the GraphicsDevice should
+			//        be managed by the GraphicsDevice itself.  Not by
+			//        iOSGamePlatform.
+			var gdm = (GraphicsDeviceManager) Game.Services.GetService (typeof (IGraphicsDeviceManager));
+
+            TouchPanel.DisplayOrientation = orientation;
+
+			if (gdm != null)
+			{	
+
+				var presentParams = gdm.GraphicsDevice.PresentationParameters;
+				presentParams.BackBufferWidth = gdm.PreferredBackBufferWidth;
+				presentParams.BackBufferHeight = gdm.PreferredBackBufferHeight;
+
+				presentParams.DisplayOrientation = orientation;
+
+                // Recalculate our views.
+                ViewController.View.LayoutSubviews();
+				
+                gdm.ApplyChanges();
+			}
+			
+		}
+
+		public override void BeginScreenDeviceChange (bool willBeFullScreen)
+		{
+		}
+
+		public override void EndScreenDeviceChange (string screenDeviceName, int clientWidth,int clientHeight)
+		{
+		}
+	}
+}
diff --git a/MonoGame.Framework/iOS/iOSGameView.cs b/MonoGame.Framework/iOS/iOSGameView.cs
new file mode 100644
index 00000000000..02288c8b20e
--- /dev/null
+++ b/MonoGame.Framework/iOS/iOSGameView.cs
@@ -0,0 +1,402 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009-2012 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+1. Definitions
+
+The terms "reproduce," "reproduction," "derivative works," and "distribution"
+have the same meaning here as under U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the
+software.
+
+A "contributor" is any person that distributes its contribution under this
+license.
+
+"Licensed patents" are a contributor's patent claims that read directly on its
+contribution.
+
+2. Grant of Rights
+
+(A) Copyright Grant- Subject to the terms of this license, including the
+license conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free copyright license to reproduce its
+contribution, prepare derivative works of its contribution, and distribute its
+contribution or any derivative works that you create.
+
+(B) Patent Grant- Subject to the terms of this license, including the license
+conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free license under its licensed patents to
+make, have made, use, sell, offer for sale, import, and/or otherwise dispose of
+its contribution in the software or derivative works of the contribution in the
+software.
+
+3. Conditions and Limitations
+
+(A) No Trademark License- This license does not grant you rights to use any
+contributors' name, logo, or trademarks.
+
+(B) If you bring a patent claim against any contributor over patents that you
+claim are infringed by the software, your patent license from such contributor
+to the software ends automatically.
+
+(C) If you distribute any portion of the software, you must retain all
+copyright, patent, trademark, and attribution notices that are present in the
+software.
+
+(D) If you distribute any portion of the software in source code form, you may
+do so only under this license by including a complete copy of this license with
+your distribution. If you distribute any portion of the software in compiled or
+object code form, you may only do so under a license that complies with this
+license.
+
+(E) The software is licensed "as-is." You bear the risk of using it. The
+contributors give no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the contributors exclude
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.
+*/
+
+
+#endregion License
+
+using System;
+using System.Drawing;
+
+using CoreAnimation;
+using Foundation;
+using ObjCRuntime;
+using OpenGLES;
+using UIKit;
+using CoreGraphics;
+
+using MonoGame.OpenGL;
+
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input.Touch;
+
+namespace Microsoft.Xna.Framework {
+
+    [Register("iOSGameView")]
+	partial class iOSGameView : UIView {
+		private readonly iOSGamePlatform _platform;
+		private int _colorbuffer;
+		private int _depthbuffer;
+		private int _framebuffer;
+
+		#region Construction/Destruction
+		public iOSGameView (iOSGamePlatform platform, CGRect frame)
+			: base(frame)
+		{
+			if (platform == null)
+				throw new ArgumentNullException ("platform");
+			_platform = platform;
+			Initialize ();
+		}
+
+		private void Initialize ()
+		{
+            #if !TVOS
+			MultipleTouchEnabled = true;
+            #endif
+			Opaque = true;
+		}
+
+		protected override void Dispose (bool disposing)
+		{
+			if (disposing) {
+				if (__renderbuffergraphicsContext != null)
+					DestroyContext();
+			}
+
+			base.Dispose (disposing);
+			_isDisposed = true;
+		}
+
+		#endregion Construction/Destruction
+
+		#region Properties
+
+		private bool _isDisposed;
+
+		public bool IsDisposed {
+			get { return _isDisposed; }
+		}
+
+		#endregion Properties
+
+		[Export ("layerClass")]
+		public static Class GetLayerClass ()
+		{
+			return new Class (typeof (CAEAGLLayer));
+		}
+
+		public override bool CanBecomeFirstResponder {
+			get { return true; }
+		}
+
+		private new CAEAGLLayer Layer {
+			get { return base.Layer as CAEAGLLayer; }
+		}
+
+		// FIXME: Someday, hopefully it will be possible to move
+		//        GraphicsContext into an iOS-specific GraphicsDevice.
+		//        Some level of cooperation with the UIView/Layer will
+		//        probably always be necessary, unfortunately.
+		private IGraphicsContext __renderbuffergraphicsContext;
+		private IOpenGLApi _glapi;
+		private void CreateContext ()
+		{
+			AssertNotDisposed ();
+
+            // RetainedBacking controls if the content of the colorbuffer should be preserved after being displayed
+            // This is the XNA equivalent to set PreserveContent when initializing the GraphicsDevice
+            // (should be false by default for better performance)
+			Layer.DrawableProperties = NSDictionary.FromObjectsAndKeys (
+				new NSObject [] {
+					NSNumber.FromBoolean (false), 
+					EAGLColorFormat.RGBA8
+				},
+				new NSObject [] {
+					EAGLDrawableProperty.RetainedBacking,
+					EAGLDrawableProperty.ColorFormat
+				});
+
+			Layer.ContentsScale = Window.Screen.Scale;
+
+			//var strVersion = OpenTK.Graphics.ES11.GL.GetString (OpenTK.Graphics.ES11.All.Version);
+			//strVersion = OpenTK.Graphics.ES20.GL.GetString (OpenTK.Graphics.ES20.All.Version);
+			//var version = Version.Parse (strVersion);
+
+			try {
+                __renderbuffergraphicsContext = GL.CreateContext (null);
+                //new GraphicsContext (null, null, 2, 0, GraphicsContextFlags.Embedded)
+            } catch (Exception ex) {
+                throw new Exception ("Device not Supported. GLES 2.0 or above is required!");
+			}
+
+			this.MakeCurrent();
+            _glapi = new Gles20Api();
+		}
+
+		private void DestroyContext ()
+		{
+			AssertNotDisposed ();
+			AssertValidContext ();
+
+			__renderbuffergraphicsContext.Dispose ();
+			__renderbuffergraphicsContext = null;
+			_glapi = null;
+		}
+
+        [Export("doTick")]
+        void DoTick()
+        {
+            _platform.Tick();
+        }
+
+		private void CreateFramebuffer ()
+		{
+			this.MakeCurrent();
+			
+			// HACK:  GraphicsDevice itself should be calling
+			//        glViewport, so we shouldn't need to do it
+			//        here and then force the state into
+			//        GraphicsDevice.  However, that change is a
+			//        ways off, yet.
+            int viewportHeight = (int)Math.Round(Layer.Bounds.Size.Height * Layer.ContentsScale);
+            int viewportWidth = (int)Math.Round(Layer.Bounds.Size.Width * Layer.ContentsScale);
+
+			_glapi.GenFramebuffers (1, ref _framebuffer);
+            _glapi.BindFramebuffer (FramebufferTarget.Framebuffer, _framebuffer);
+
+			// Create our Depth buffer. Color buffer must be the last one bound
+            var gdm = _platform.Game.Services.GetService(
+                typeof(IGraphicsDeviceManager)) as GraphicsDeviceManager;
+            if (gdm != null)
+            {
+                var preferredDepthFormat = gdm.PreferredDepthStencilFormat;
+                if (preferredDepthFormat != DepthFormat.None)
+                {
+                    GL.GenRenderbuffers(1, out _depthbuffer);
+                    GL.BindRenderbuffer(RenderbufferTarget.Renderbuffer, _depthbuffer);
+                    var internalFormat = RenderbufferStorage.DepthComponent16;
+                    if (preferredDepthFormat == DepthFormat.Depth24)
+                        internalFormat = RenderbufferStorage.DepthComponent24Oes;
+                    else if (preferredDepthFormat == DepthFormat.Depth24Stencil8)
+                        internalFormat = RenderbufferStorage.Depth24Stencil8Oes;
+                    GL.RenderbufferStorage(RenderbufferTarget.Renderbuffer, internalFormat, viewportWidth, viewportHeight);
+                    GL.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthAttachment, RenderbufferTarget.Renderbuffer, _depthbuffer);
+                    if (preferredDepthFormat == DepthFormat.Depth24Stencil8)
+                        GL.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.StencilAttachment, RenderbufferTarget.Renderbuffer, _depthbuffer);
+                }
+            }
+
+			_glapi.GenRenderbuffers(1, ref _colorbuffer);
+            _glapi.BindRenderbuffer(RenderbufferTarget.Renderbuffer, _colorbuffer);
+
+			var ctx = __renderbuffergraphicsContext as GraphicsContext;
+
+			// TODO: EAGLContext.RenderBufferStorage returns false
+			//       on all but the first call.  Nevertheless, it
+			//       works.  Still, it would be nice to know why it
+			//       claims to have failed.
+            ctx.Context.RenderBufferStorage ((uint) RenderbufferTarget.Renderbuffer, Layer);
+			
+            _glapi.FramebufferRenderbuffer (FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, RenderbufferTarget.Renderbuffer, _colorbuffer);
+			
+			var status = GL.CheckFramebufferStatus(FramebufferTarget.Framebuffer);
+			if (status != FramebufferErrorCode.FramebufferComplete)
+				throw new InvalidOperationException (
+					"Framebuffer was not created correctly: " + status);
+
+			_glapi.Viewport(0, 0, viewportWidth, viewportHeight);
+            _glapi.Scissor(0, 0, viewportWidth, viewportHeight);
+
+			var gds = _platform.Game.Services.GetService(
+                typeof (IGraphicsDeviceService)) as IGraphicsDeviceService;
+
+			if (gds != null && gds.GraphicsDevice != null)
+			{
+                var pp = gds.GraphicsDevice.PresentationParameters;
+                int height = viewportHeight;
+                int width = viewportWidth;
+
+                if (this.NextResponder is iOSGameViewController)
+                {
+                    var displayOrientation = _platform.Game.Window.CurrentOrientation;
+                    if (displayOrientation == DisplayOrientation.LandscapeLeft || displayOrientation == DisplayOrientation.LandscapeRight)
+                    {
+                        height = Math.Min(viewportHeight, viewportWidth);
+                        width = Math.Max(viewportHeight, viewportWidth);
+                    }
+                    else
+                    {
+                        height = Math.Max(viewportHeight, viewportWidth);
+                        width = Math.Min(viewportHeight, viewportWidth);
+                    }
+                }
+
+                pp.BackBufferHeight = height;
+                pp.BackBufferWidth = width;
+
+				gds.GraphicsDevice.Viewport = new Viewport(
+					0, 0,
+					pp.BackBufferWidth,
+					pp.BackBufferHeight);
+				
+				// FIXME: These static methods on GraphicsDevice need
+				//        to go away someday.
+				gds.GraphicsDevice.glFramebuffer = _framebuffer;
+			}
+
+            if (Threading.BackgroundContext == null)
+                Threading.BackgroundContext = new OpenGLES.EAGLContext(ctx.Context.API, ctx.Context.ShareGroup);
+		}
+
+		private void DestroyFramebuffer ()
+		{
+			AssertNotDisposed ();
+			AssertValidContext ();
+
+			__renderbuffergraphicsContext.MakeCurrent (null);
+
+			_glapi.DeleteFramebuffers (1, ref _framebuffer);
+			_framebuffer = 0;
+
+			_glapi.DeleteRenderbuffers (1, ref _colorbuffer);
+			_colorbuffer = 0;
+			
+            if (_depthbuffer != 0)
+            {
+			    _glapi.DeleteRenderbuffers (1, ref _depthbuffer);
+			    _depthbuffer = 0;
+            }
+		}
+
+        private static readonly FramebufferAttachment[] attachements = new FramebufferAttachment[] { FramebufferAttachment.DepthAttachment, FramebufferAttachment.StencilAttachment };
+
+		// FIXME: This logic belongs in GraphicsDevice.Present, not
+		//        here.  If it can someday be moved there, then the
+		//        normal call to Present in Game.Tick should cover
+		//        this.  For now, iOSGamePlatform will call Present
+		//        in the Draw/Update loop handler.
+		public void Present ()
+		{
+            AssertNotDisposed ();
+            AssertValidContext ();
+
+            this.MakeCurrent();
+            GL.BindRenderbuffer(RenderbufferTarget.Renderbuffer, this._colorbuffer);
+            GL.InvalidateFramebuffer(FramebufferTarget.Framebuffer, 2, attachements);
+            __renderbuffergraphicsContext.SwapBuffers();
+		}
+
+		// FIXME: This functionality belongs in GraphicsDevice.
+		public void MakeCurrent ()
+		{
+			AssertNotDisposed ();
+			AssertValidContext ();
+
+            if (!__renderbuffergraphicsContext.IsCurrent)
+            {
+			    __renderbuffergraphicsContext.MakeCurrent (null);
+            }
+		}
+
+		public override void LayoutSubviews ()
+		{
+			base.LayoutSubviews ();
+
+            var gds = _platform.Game.Services.GetService (
+                typeof (IGraphicsDeviceService)) as IGraphicsDeviceService;
+
+            if (gds == null || gds.GraphicsDevice == null)
+                return;
+
+			if (_framebuffer != 0)
+				DestroyFramebuffer ();
+			if (__renderbuffergraphicsContext == null)
+				CreateContext();
+			CreateFramebuffer ();
+		}
+
+		#region UIWindow Notifications
+
+		[Export ("didMoveToWindow")]
+		public virtual void DidMoveToWindow ()
+		{
+
+            if (Window != null) {
+                
+                if (__renderbuffergraphicsContext == null)
+                    CreateContext ();
+                if (_framebuffer == 0)
+                    CreateFramebuffer ();
+            }
+		}
+
+		#endregion UIWindow Notifications
+
+		private void AssertNotDisposed ()
+		{
+			if (_isDisposed)
+				throw new ObjectDisposedException (GetType ().Name);
+		}
+
+		private void AssertValidContext ()
+		{
+			if (__renderbuffergraphicsContext == null)
+				throw new InvalidOperationException (
+					"GraphicsContext must be created for this operation to succeed.");
+		}
+	}
+}
diff --git a/MonoGame.Framework/iOS/iOSGameViewController.cs b/MonoGame.Framework/iOS/iOSGameViewController.cs
new file mode 100644
index 00000000000..f385f4a917b
--- /dev/null
+++ b/MonoGame.Framework/iOS/iOSGameViewController.cs
@@ -0,0 +1,213 @@
+// MonoGame - Copyright (C) The MonoGame Team
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE.txt', which is part of this source code package.
+
+using System;
+using System.Drawing;
+
+using UIKit;
+using Foundation;
+using CoreGraphics;
+
+namespace Microsoft.Xna.Framework
+{
+    class iOSGameViewController : 
+    #if TVOS
+        GameController.GCEventViewController
+    #else
+        UIViewController
+    #endif
+    {
+        iOSGamePlatform _platform;
+        #if TVOS
+        IPlatformBackButton platformBackButton;
+        #endif
+
+        public iOSGameViewController(iOSGamePlatform platform)
+        {
+            if (platform == null)
+                throw new ArgumentNullException("platform");
+            _platform = platform;
+            SupportedOrientations = 
+                DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight 
+                | DisplayOrientation.Portrait | DisplayOrientation.PortraitDown;
+        }
+
+        public event EventHandler<EventArgs> InterfaceOrientationChanged;
+
+        public DisplayOrientation SupportedOrientations { get; set; }
+
+        public override void LoadView()
+        {
+			CGRect frame;
+            if (ParentViewController != null && ParentViewController.View != null)
+            {
+				frame = new CGRect(CGPoint.Empty, ParentViewController.View.Frame.Size);
+            }
+            else
+            {
+                UIScreen screen = UIScreen.MainScreen;
+
+                #if !TVOS
+                // iOS 7 and older reverses width/height in landscape mode when reporting resolution,
+                // iOS 8+ reports resolution correctly in all cases
+                if (InterfaceOrientation == UIInterfaceOrientation.LandscapeLeft || InterfaceOrientation == UIInterfaceOrientation.LandscapeRight)
+                {
+					frame = new CGRect(0, 0, (nfloat)Math.Max(screen.Bounds.Width, screen.Bounds.Height), (nfloat)Math.Min(screen.Bounds.Width, screen.Bounds.Height));
+                }
+                else
+                {
+					frame = new CGRect(0, 0, screen.Bounds.Width, screen.Bounds.Height);
+                }
+                #else
+                frame = new CGRect(0, 0, screen.Bounds.Width, screen.Bounds.Height);
+                #endif
+            }
+
+            base.View = new iOSGameView(_platform, frame);
+
+            // Need to set resize mask to ensure a view resize (which in iOS 8+ corresponds with a rotation) adjusts
+            // the view and underlying CALayer correctly
+            View.AutoresizingMask = UIViewAutoresizing.FlexibleWidth | UIViewAutoresizing.FlexibleHeight;
+            #if TVOS
+            ControllerUserInteractionEnabled = false;
+            #endif
+        }
+
+        public new iOSGameView View
+        {
+            get { return (iOSGameView)base.View; }
+        }
+        #if !TVOS
+
+        #region Autorotation for iOS 5 or older
+        public override bool ShouldAutorotateToInterfaceOrientation(UIInterfaceOrientation toInterfaceOrientation)
+        {
+            DisplayOrientation supportedOrientations = OrientationConverter.Normalize(SupportedOrientations);
+            var toOrientation = OrientationConverter.ToDisplayOrientation(toInterfaceOrientation);
+            return (toOrientation & supportedOrientations) == toOrientation;
+        }
+        #endregion
+
+        #region Autorotation for iOS 6 or newer
+        public override UIInterfaceOrientationMask GetSupportedInterfaceOrientations()
+        {
+            return OrientationConverter.ToUIInterfaceOrientationMask(this.SupportedOrientations);
+        }
+
+        public override bool ShouldAutorotate()
+        {
+            return true;
+        }
+        #endregion
+
+        public override void DidRotate(UIInterfaceOrientation fromInterfaceOrientation)
+        {
+            base.DidRotate(fromInterfaceOrientation);
+            EventHelpers.Raise(this, InterfaceOrientationChanged, EventArgs.Empty);
+        }
+        #region Hide statusbar for iOS 7 or newer
+        public override bool PrefersStatusBarHidden()
+        {
+            return _platform.Game.graphicsDeviceManager.IsFullScreen;
+        }
+        #endregion
+
+
+
+
+        #region iOS 8 or newer
+
+		public override void ViewWillTransitionToSize(CGSize toSize, IUIViewControllerTransitionCoordinator coordinator)
+        {
+			CGSize oldSize = View.Bounds.Size;
+
+            if (oldSize != toSize)
+            {
+                UIInterfaceOrientation prevOrientation = InterfaceOrientation;
+
+                // In iOS 8+ DidRotate is no longer called after a rotation
+                // But we need to notify iOSGamePlatform to update back buffer so we explicitly call it 
+
+                // We do this within the animateAlongside action, which at the point of calling
+                // will have the new InterfaceOrientation set
+                coordinator.AnimateAlongsideTransition((context) =>
+                    {
+                        DidRotate(prevOrientation);
+                    }, (context) => 
+                    {
+                    });
+
+            }
+
+            base.ViewWillTransitionToSize(toSize, coordinator);
+        }
+
+        #endregion
+
+        #region iOS 11 or newer
+
+        /// <summary>
+        /// Defer system gestures on all screen edges in full screen mode.
+        /// </summary>
+        public override UIRectEdge PreferredScreenEdgesDeferringSystemGestures
+        {
+            get
+            {
+                return _platform.Game.graphicsDeviceManager.IsFullScreen ? UIRectEdge.All : base.PreferredScreenEdgesDeferringSystemGestures;
+            }
+        }
+
+        #endregion
+
+        #endif
+
+        #if TVOS
+
+        public override UIView PreferredFocusedView
+        {
+            get
+            {
+                return this.View;
+            }
+        }
+
+        public override void PressesBegan(NSSet<UIPress> presses, UIPressesEvent evt)
+        {
+            if (presses.Count == 0)
+                return;
+            foreach (UIPress press in presses)
+            {
+                if (press.Type == UIPressType.Menu)
+                {
+                    if (platformBackButton == null)
+                        platformBackButton = _platform.Game.Services.GetService<IPlatformBackButton>();
+                    if (platformBackButton != null)
+                    {
+                        if (!platformBackButton.Handled())
+                        {
+                            ControllerUserInteractionEnabled = true;
+                        }
+                        else
+                        {
+                            Microsoft.Xna.Framework.Input.GamePad.MenuPressed = true;
+                        }
+                    }
+                    else
+                    {
+                        ControllerUserInteractionEnabled = true;
+                    }
+                }
+            }
+            if (ControllerUserInteractionEnabled)
+                base.PressesBegan(presses, evt);
+        }
+
+        public override void PressesEnded(NSSet<UIPress> presses, UIPressesEvent evt)
+        {
+            if (ControllerUserInteractionEnabled)
+                base.PressesEnded(presses, evt);
+        }
+        #endif
+    }
+}
diff --git a/MonoGame.Framework/iOS/iOSGameView_GLAbstraction.cs b/MonoGame.Framework/iOS/iOSGameView_GLAbstraction.cs
new file mode 100644
index 00000000000..5bf52738b80
--- /dev/null
+++ b/MonoGame.Framework/iOS/iOSGameView_GLAbstraction.cs
@@ -0,0 +1,154 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009-2012 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+1. Definitions
+
+The terms "reproduce," "reproduction," "derivative works," and "distribution"
+have the same meaning here as under U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the
+software.
+
+A "contributor" is any person that distributes its contribution under this
+license.
+
+"Licensed patents" are a contributor's patent claims that read directly on its
+contribution.
+
+2. Grant of Rights
+
+(A) Copyright Grant- Subject to the terms of this license, including the
+license conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free copyright license to reproduce its
+contribution, prepare derivative works of its contribution, and distribute its
+contribution or any derivative works that you create.
+
+(B) Patent Grant- Subject to the terms of this license, including the license
+conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free license under its licensed patents to
+make, have made, use, sell, offer for sale, import, and/or otherwise dispose of
+its contribution in the software or derivative works of the contribution in the
+software.
+
+3. Conditions and Limitations
+
+(A) No Trademark License- This license does not grant you rights to use any
+contributors' name, logo, or trademarks.
+
+(B) If you bring a patent claim against any contributor over patents that you
+claim are infringed by the software, your patent license from such contributor
+to the software ends automatically.
+
+(C) If you distribute any portion of the software, you must retain all
+copyright, patent, trademark, and attribution notices that are present in the
+software.
+
+(D) If you distribute any portion of the software in source code form, you may
+do so only under this license by including a complete copy of this license with
+your distribution. If you distribute any portion of the software in compiled or
+object code form, you may only do so under a license that complies with this
+license.
+
+(E) The software is licensed "as-is." You bear the risk of using it. The
+contributors give no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the contributors exclude
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.
+*/
+#endregion License
+
+using MonoGame.OpenGL;
+using System;
+
+namespace Microsoft.Xna.Framework {
+	partial class iOSGameView {
+        private interface IOpenGLApi
+        {
+            FramebufferErrorCode CheckFramebufferStatus (FramebufferTarget target);
+            void BindFramebuffer (FramebufferTarget target, int framebuffer);
+            void BindRenderbuffer (RenderbufferTarget target, int renderbuffer);
+            void DeleteFramebuffers (int n, ref int framebuffers);
+            void DeleteRenderbuffers (int n, ref int renderbuffers);
+            void FramebufferRenderbuffer (FramebufferTarget target, FramebufferAttachment attachment, RenderbufferTarget renderbuffertarget, int renderbuffer);
+            void GenFramebuffers (int n, ref int framebuffers);
+            void GenRenderbuffers (int n, ref int renderbuffers);
+            void GetInteger (GetPName name, ref int value);
+            void Scissor (int x, int y, int width, int height);
+			void Viewport (int x, int y, int width, int height);
+        }
+
+		private class Gles20Api : IOpenGLApi {
+
+            public Gles20Api()
+            {
+                GL.LoadEntryPoints();
+            }
+
+            public FramebufferErrorCode CheckFramebufferStatus (FramebufferTarget target)
+			{
+				return GL.CheckFramebufferStatus (target);
+			}
+
+			public void BindFramebuffer (FramebufferTarget target, int framebuffer)
+			{
+                GL.BindFramebuffer(target, framebuffer);
+			}
+
+			public void BindRenderbuffer (RenderbufferTarget target, int renderbuffer)
+			{
+				GL.BindRenderbuffer (target, renderbuffer);
+			}
+
+			public void DeleteFramebuffers (int n, ref int framebuffers)
+			{
+				GL.DeleteFramebuffers (n, ref framebuffers);
+			}
+
+			public void DeleteRenderbuffers (int n, ref int renderbuffers)
+			{
+				GL.DeleteRenderbuffers (n, ref renderbuffers);
+			}
+
+			public void FramebufferRenderbuffer (
+				FramebufferTarget target, FramebufferAttachment attachment, RenderbufferTarget renderbuffertarget, int renderbuffer)
+			{
+                GL.FramebufferRenderbuffer (target, attachment, renderbuffertarget, renderbuffer);
+			}
+
+			public void GenFramebuffers (int n, ref int framebuffers)
+			{
+				GL.GenFramebuffers (n, out framebuffers);
+			}
+
+			public void GenRenderbuffers (int n, ref int renderbuffers)
+			{
+				GL.GenRenderbuffers (n, out renderbuffers);
+			}
+
+			public void GetInteger (GetPName name, ref int value)
+			{
+				GL.GetInteger (name, out value);
+			}
+
+			public void Scissor (int x, int y, int width, int height)
+			{
+				GL.Scissor (x, y, width, height);
+			}
+
+			public void Viewport (int x, int y, int width, int height)
+			{
+				GL.Viewport (x, y, width, height);
+			}
+		}
+	}
+}
+
diff --git a/MonoGame.Framework/iOS/iOSGameView_Touch.cs b/MonoGame.Framework/iOS/iOSGameView_Touch.cs
new file mode 100644
index 00000000000..bd337ca5dd0
--- /dev/null
+++ b/MonoGame.Framework/iOS/iOSGameView_Touch.cs
@@ -0,0 +1,160 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009-2012 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+1. Definitions
+
+The terms "reproduce," "reproduction," "derivative works," and "distribution"
+have the same meaning here as under U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the
+software.
+
+A "contributor" is any person that distributes its contribution under this
+license.
+
+"Licensed patents" are a contributor's patent claims that read directly on its
+contribution.
+
+2. Grant of Rights
+
+(A) Copyright Grant- Subject to the terms of this license, including the
+license conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free copyright license to reproduce its
+contribution, prepare derivative works of its contribution, and distribute its
+contribution or any derivative works that you create.
+
+(B) Patent Grant- Subject to the terms of this license, including the license
+conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free license under its licensed patents to
+make, have made, use, sell, offer for sale, import, and/or otherwise dispose of
+its contribution in the software or derivative works of the contribution in the
+software.
+
+3. Conditions and Limitations
+
+(A) No Trademark License- This license does not grant you rights to use any
+contributors' name, logo, or trademarks.
+
+(B) If you bring a patent claim against any contributor over patents that you
+claim are infringed by the software, your patent license from such contributor
+to the software ends automatically.
+
+(C) If you distribute any portion of the software, you must retain all
+copyright, patent, trademark, and attribution notices that are present in the
+software.
+
+(D) If you distribute any portion of the software in source code form, you may
+do so only under this license by including a complete copy of this license with
+your distribution. If you distribute any portion of the software in compiled or
+object code form, you may only do so under a license that complies with this
+license.
+
+(E) The software is licensed "as-is." You bear the risk of using it. The
+contributors give no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the contributors exclude
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.
+*/
+#endregion License
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+
+using Foundation;
+using ObjCRuntime;
+using UIKit;
+
+using Microsoft.Xna.Framework.Input;
+using Microsoft.Xna.Framework.Input.Touch;
+
+namespace Microsoft.Xna.Framework {
+	partial class iOSGameView {
+		
+		static GestureType EnabledGestures
+		{
+			get { return TouchPanel.EnabledGestures; }
+		}
+		
+		#region Touches
+
+		public override void TouchesBegan (NSSet touches, UIEvent evt)
+		{
+			base.TouchesBegan (touches, evt);
+			FillTouchCollection (touches);
+		}
+
+		public override void TouchesEnded (NSSet touches, UIEvent evt)
+		{
+			base.TouchesEnded (touches, evt);
+			FillTouchCollection (touches);
+		}
+
+		public override void TouchesMoved (NSSet touches, UIEvent evt)
+		{
+			base.TouchesMoved (touches, evt);
+			FillTouchCollection (touches);
+		}
+
+		public override void TouchesCancelled (NSSet touches, UIEvent evt)
+		{
+			base.TouchesCancelled (touches, evt);
+			FillTouchCollection (touches);
+		}
+		
+		// TODO: Review FillTouchCollection
+		private void FillTouchCollection (NSSet touches)
+		{
+			if (touches.Count == 0)
+				return;
+
+			var touchesArray = touches.ToArray<UITouch> ();
+			for (int i = 0; i < touchesArray.Length; ++i) {
+				var touch = touchesArray [i];
+
+				//Get position touch
+				var location = touch.LocationInView (touch.View);
+				var position = GetOffsetPosition (new Vector2 ((float)location.X, (float)location.Y), true);
+				var id = touch.Handle.ToInt32 ();
+
+				switch (touch.Phase) 
+                {
+				//case UITouchPhase.Stationary:
+				case UITouchPhase.Moved:
+					TouchPanel.AddEvent(id, TouchLocationState.Moved, position);					
+					break;
+				case UITouchPhase.Began:
+                    TouchPanel.AddEvent(id, TouchLocationState.Pressed, position);
+					break;
+				case UITouchPhase.Ended	:
+                    TouchPanel.AddEvent(id, TouchLocationState.Released, position);
+					break;
+				case UITouchPhase.Cancelled:
+                    TouchPanel.AddEvent(id, TouchLocationState.Released, position);
+					break;
+				default:
+					break;
+				}
+			}
+		}
+		
+		// TODO: Review GetOffsetPosition, hopefully it can be removed now.
+		public Vector2 GetOffsetPosition (Vector2 position, bool useScale)
+		{
+			if (useScale)
+				return position * (float)Layer.ContentsScale;
+			return position;
+		}
+
+		#endregion Touches
+	}
+}
diff --git a/MonoGame.Framework/iOS/iOSGameWindow.cs b/MonoGame.Framework/iOS/iOSGameWindow.cs
new file mode 100644
index 00000000000..bc9abcfafa0
--- /dev/null
+++ b/MonoGame.Framework/iOS/iOSGameWindow.cs
@@ -0,0 +1,187 @@
+#region License
+/*
+Microsoft Public License (Ms-PL)
+MonoGame - Copyright © 2009-2012 The MonoGame Team
+
+All rights reserved.
+
+This license governs use of the accompanying software. If you use the software,
+you accept this license. If you do not accept the license, do not use the
+software.
+
+1. Definitions
+
+The terms "reproduce," "reproduction," "derivative works," and "distribution"
+have the same meaning here as under U.S. copyright law.
+
+A "contribution" is the original software, or any additions or changes to the
+software.
+
+A "contributor" is any person that distributes its contribution under this
+license.
+
+"Licensed patents" are a contributor's patent claims that read directly on its
+contribution.
+
+2. Grant of Rights
+
+(A) Copyright Grant- Subject to the terms of this license, including the
+license conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free copyright license to reproduce its
+contribution, prepare derivative works of its contribution, and distribute its
+contribution or any derivative works that you create.
+
+(B) Patent Grant- Subject to the terms of this license, including the license
+conditions and limitations in section 3, each contributor grants you a
+non-exclusive, worldwide, royalty-free license under its licensed patents to
+make, have made, use, sell, offer for sale, import, and/or otherwise dispose of
+its contribution in the software or derivative works of the contribution in the
+software.
+
+3. Conditions and Limitations
+
+(A) No Trademark License- This license does not grant you rights to use any
+contributors' name, logo, or trademarks.
+
+(B) If you bring a patent claim against any contributor over patents that you
+claim are infringed by the software, your patent license from such contributor
+to the software ends automatically.
+
+(C) If you distribute any portion of the software, you must retain all
+copyright, patent, trademark, and attribution notices that are present in the
+software.
+
+(D) If you distribute any portion of the software in source code form, you may
+do so only under this license by including a complete copy of this license with
+your distribution. If you distribute any portion of the software in compiled or
+object code form, you may only do so under a license that complies with this
+license.
+
+(E) The software is licensed "as-is." You bear the risk of using it. The
+contributors give no express warranties, guarantees or conditions. You may have
+additional consumer rights under your local laws which this license cannot
+change. To the extent permitted under your local laws, the contributors exclude
+the implied warranties of merchantability, fitness for a particular purpose and
+non-infringement.
+*/
+#endregion License
+
+using System;
+
+using UIKit;
+
+namespace Microsoft.Xna.Framework {
+	class iOSGameWindow : GameWindow {
+		private readonly iOSGameViewController _viewController;
+
+		public iOSGameWindow (iOSGameViewController viewController)
+		{
+			if (viewController == null)
+				throw new ArgumentNullException("viewController");
+			_viewController = viewController;
+            _viewController.InterfaceOrientationChanged += HandleInterfaceOrientationChanged;
+		}
+
+        void HandleInterfaceOrientationChanged (object sender, EventArgs e)
+        {
+            OnOrientationChanged();
+        }
+
+		#region GameWindow Members
+
+		public override bool AllowUserResizing {
+			get { return false; }
+			set { /* Do nothing. */ }
+		}
+
+		public override Rectangle ClientBounds {
+			get {
+				var bounds = _viewController.View.Bounds;
+                var scale = _viewController.View.ContentScaleFactor;
+
+                // TODO: Calculate this only when dirty.
+                if (_viewController is iOSGameViewController)
+                {
+
+                    var currentOrientation = CurrentOrientation;
+
+                    int width;
+                    int height;
+
+                    if (currentOrientation == DisplayOrientation.LandscapeLeft || 
+                        currentOrientation == DisplayOrientation.LandscapeRight)
+                    {
+                        width = (int)Math.Max(bounds.Width, bounds.Height);
+                        height = (int)Math.Min(bounds.Width, bounds.Height);
+
+                    }
+                    else
+                    {
+                        width = (int)Math.Min(bounds.Width, bounds.Height);
+                        height = (int)Math.Max(bounds.Width, bounds.Height);
+                    }
+
+                    width *= (int)scale;
+                    height *= (int)scale;
+
+                    return new Rectangle( (int)(bounds.X * scale), (int)(bounds.Y * scale), width, height);
+                }
+
+				return new Rectangle(
+                    (int)(bounds.X * scale), (int)(bounds.Y * scale),
+                    (int)(bounds.Width * scale), (int)(bounds.Height * scale));
+			}
+		}
+
+		public override DisplayOrientation CurrentOrientation {
+			get {
+                #if TVOS
+                return DisplayOrientation.LandscapeLeft;
+                #else
+				return OrientationConverter.ToDisplayOrientation(_viewController.InterfaceOrientation);
+                #endif
+			}
+		}
+
+		public override IntPtr Handle {
+			get {
+				// TODO: Verify that View.Handle is a sensible
+				//       value to return here.
+				return _viewController.View.Handle;
+			}
+		}
+
+		public override string ScreenDeviceName {
+			get {
+				var screen = _viewController.View.Window.Screen;
+				if (screen == UIScreen.MainScreen)
+					return "Main Display";
+				else
+					return "External Display";
+			}
+		}
+
+		public override void BeginScreenDeviceChange (bool willBeFullScreen)
+		{
+			throw new NotImplementedException ();
+		}
+
+		public override void EndScreenDeviceChange (
+			string screenDeviceName, int clientWidth, int clientHeight)
+		{
+			throw new NotImplementedException ();
+		}
+
+		internal protected override void SetSupportedOrientations (DisplayOrientation orientations)
+		{
+			_viewController.SupportedOrientations = orientations;
+		}
+
+		protected override void SetTitle (string title)
+		{
+			_viewController.Title = title;
+		}
+
+		#endregion GameWindow Members
+	}
+}
\ No newline at end of file