- Wrote the DualTexture shader for GL3 but the rendering is not working yet

- Huge refactoring in the Dx10 RenderSystem + increasing much performance

ANX.Framework/Game.cs

@@ -45,7 +45,6 @@ namespace ANX.Framework
 
 		private ContentManager content;
 
-        private GameComponentCollection components;
         private List<IGameComponent> drawableGameComponents;
 
         #endregion
@@ -93,9 +92,9 @@ namespace ANX.Framework
             this.TargetElapsedTime = TimeSpan.FromTicks(TimeSpan.TicksPerSecond / 60L);  // default is 1/60s 
 
             //TODO: implement draw- and update-order handling of GameComponents
-            this.components = new GameComponentCollection();
+			this.Components = new GameComponentCollection();
-            this.components.ComponentAdded += components_ComponentAdded;
+			this.Components.ComponentAdded += components_ComponentAdded;
-            this.components.ComponentRemoved += components_ComponentRemoved;
+			this.Components.ComponentRemoved += components_ComponentRemoved;
             this.drawableGameComponents = new List<IGameComponent>();
 
 			Logger.Info("finished initializing new Game class");
@@ -105,8 +104,8 @@ namespace ANX.Framework
 
 		~Game()
 		{
-            this.components.ComponentAdded -= components_ComponentAdded;
+			this.Components.ComponentAdded -= components_ComponentAdded;
-            this.components.ComponentRemoved -= components_ComponentRemoved;
+			this.Components.ComponentRemoved -= components_ComponentRemoved;
 
 			Dispose(false);
 		}
@@ -150,7 +149,7 @@ namespace ANX.Framework
 
 		protected virtual void Update(GameTime gameTime)
 		{
-            foreach (IUpdateable updateable in this.components)
+			foreach (IUpdateable updateable in this.Components)
             {
                 if (updateable.Enabled)
                 {
@@ -478,8 +477,8 @@ namespace ANX.Framework
 			if (disposing)
 			{
 				IDisposable disposable;
-				var array = new IGameComponent[components.Count];
+				var array = new IGameComponent[Components.Count];
-				components.CopyTo(array, 0);
+				Components.CopyTo(array, 0);
 				for (int i = 0; i < array.Length; i++)
 				{
 					disposable = (IDisposable)array[i];

ANX.Framework/GameComponentCollection.cs

@@ -30,9 +30,7 @@ namespace ANX.Framework
         protected override void ClearItems()
         {
             for (int i = 0; i < base.Count; i++)
-            {
                 OnComponentRemoved(base[i]);
-            }
 
             base.Clear();
         }
@@ -40,9 +38,7 @@ namespace ANX.Framework
         protected override void InsertItem(int index, IGameComponent item)
         {
             if (item == null)
-            {
                 throw new ArgumentNullException("item");
-            }
 
             base.Insert(index, item);
             OnComponentAdded(item);
@@ -64,17 +60,13 @@ namespace ANX.Framework
         private void OnComponentAdded(IGameComponent component)
         {
             if (ComponentAdded != null)
-            {
                 ComponentAdded(this, new GameComponentCollectionEventArgs(component));
-            }
         }
 
         private void OnComponentRemoved(IGameComponent component)
         {
             if (ComponentRemoved != null)
-            {
                 ComponentRemoved(this, new GameComponentCollectionEventArgs(component));
-            }
         }
     }
 }

ANX.Framework/Graphics/AlphaTestEffect.cs

@@ -9,9 +9,8 @@ namespace ANX.Framework.Graphics
 {
     public class AlphaTestEffect : Effect, IEffectMatrices, IEffectFog, IGraphicsResource
     {
-        public AlphaTestEffect(GraphicsDevice device)
+		public AlphaTestEffect(GraphicsDevice device)
-            : base(device, AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>().GetShaderByteCode(
+			: base(device, GetByteCode(), GetSourceLanguage())
-			NonXNA.PreDefinedShader.AlphaTestEffect))
         {
             throw new NotImplementedException();
         }
@@ -20,7 +19,23 @@ namespace ANX.Framework.Graphics
             : base(cloneSource)
         {
             throw new NotImplementedException();
-        }
+		}
+
+		#region GetByteCode
+		private static byte[] GetByteCode()
+		{
+			var creator = AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>();
+			return creator.GetShaderByteCode(PreDefinedShader.AlphaTestEffect);
+		}
+		#endregion
+
+		#region GetSourceLanguage
+		private static EffectSourceLanguage GetSourceLanguage()
+		{
+			var creator = AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>();
+			return creator.GetStockShaderSourceLanguage;
+		}
+		#endregion
 
         public override Effect Clone()
         {

ANX.Framework/Graphics/BasicEffect.cs

@@ -30,8 +30,8 @@ namespace ANX.Framework.Graphics
         private DirectionalLight[] directionalLight;
         private Vector3 ambientLightColor;
 
-        public BasicEffect(GraphicsDevice graphics)
+		public BasicEffect(GraphicsDevice graphics)
-            : base(graphics, AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>().GetShaderByteCode(NonXNA.PreDefinedShader.BasicEffect))
+			: base(graphics, GetByteCode(), GetSourceLanguage())
         {
             world = base.Parameters["World"];
             view = base.Parameters["View"];
@@ -54,7 +54,23 @@ namespace ANX.Framework.Graphics
             : base(cloneSource)
         {
             throw new NotImplementedException();
-        }
+		}
+
+		#region GetByteCode
+		private static byte[] GetByteCode()
+		{
+			var creator = AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>();
+			return creator.GetShaderByteCode(PreDefinedShader.BasicEffect);
+		}
+		#endregion
+
+		#region GetSourceLanguage
+		private static EffectSourceLanguage GetSourceLanguage()
+		{
+			var creator = AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>();
+			return creator.GetStockShaderSourceLanguage;
+		}
+		#endregion
 
         public bool PreferPerPixelLighting
         {

ANX.Framework/Graphics/DualTextureEffect.cs

@@ -83,8 +83,7 @@ namespace ANX.Framework.Graphics
 
 		#region Constructor
 		public DualTextureEffect(GraphicsDevice graphics)
-            : base(graphics, AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>().GetShaderByteCode(
+			: base(graphics, GetByteCode(), GetSourceLanguage())
-				NonXNA.PreDefinedShader.DualTextureEffect))
         {
 			diffuseColor = Vector3.One;
 			Alpha = 1f;
@@ -114,6 +113,22 @@ namespace ANX.Framework.Graphics
         }
 		#endregion
 
+		#region GetByteCode
+		private static byte[] GetByteCode()
+		{
+			var creator = AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>();
+			return creator.GetShaderByteCode(PreDefinedShader.DualTextureEffect);
+		}
+		#endregion
+
+		#region GetSourceLanguage
+		private static EffectSourceLanguage GetSourceLanguage()
+		{
+			var creator = AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>();
+			return creator.GetStockShaderSourceLanguage;
+		}
+		#endregion
+
 		#region Clone
 		public override Effect Clone()
         {

ANX.Framework/Graphics/EnvironmentMapEffect.cs

@@ -15,8 +15,8 @@ namespace ANX.Framework.Graphics
 {
     public class EnvironmentMapEffect : Effect, IEffectMatrices, IEffectLights, IEffectFog
     {
-        public EnvironmentMapEffect(GraphicsDevice graphics)
+		public EnvironmentMapEffect(GraphicsDevice graphics)
-            : base(graphics, AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>().GetShaderByteCode(NonXNA.PreDefinedShader.EnvironmentMapEffect))
+			: base(graphics, GetByteCode(), GetSourceLanguage())
         {
             throw new NotImplementedException();
         }
@@ -25,7 +25,23 @@ namespace ANX.Framework.Graphics
             : base(cloneSource)
         {
             throw new NotImplementedException();
-        }
+		}
+
+		#region GetByteCode
+		private static byte[] GetByteCode()
+		{
+			var creator = AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>();
+			return creator.GetShaderByteCode(PreDefinedShader.EnvironmentMapEffect);
+		}
+		#endregion
+
+		#region GetSourceLanguage
+		private static EffectSourceLanguage GetSourceLanguage()
+		{
+			var creator = AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>();
+			return creator.GetStockShaderSourceLanguage;
+		}
+		#endregion
 
         public override Effect Clone()
         {

ANX.Framework/Graphics/SkinnedEffect.cs

@@ -18,8 +18,8 @@ namespace ANX.Framework.Graphics
 {
     public class SkinnedEffect : Effect, IEffectMatrices, IEffectLights, IEffectFog
     {
-        public SkinnedEffect(GraphicsDevice graphics)
+		public SkinnedEffect(GraphicsDevice graphics)
-            : base(graphics, AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>().GetShaderByteCode(NonXNA.PreDefinedShader.SkinnedEffect))
+			: base(graphics, GetByteCode(), GetSourceLanguage())
         {
             throw new NotImplementedException();
         }
@@ -28,7 +28,23 @@ namespace ANX.Framework.Graphics
             : base(cloneSource)
         {
             throw new NotImplementedException();
-        }
+		}
+
+		#region GetByteCode
+		private static byte[] GetByteCode()
+		{
+			var creator = AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>();
+			return creator.GetShaderByteCode(PreDefinedShader.SkinnedEffect);
+		}
+		#endregion
+
+		#region GetSourceLanguage
+		private static EffectSourceLanguage GetSourceLanguage()
+		{
+			var creator = AddInSystemFactory.Instance.GetDefaultCreator<IRenderSystemCreator>();
+			return creator.GetStockShaderSourceLanguage;
+		}
+		#endregion
 
         public override Effect Clone()
         {

RenderSystems/ANX.Framework.Windows.DX10/ANX.RenderSystem.Windows.DX10.csproj

@@ -82,9 +82,10 @@
     <Compile Include="EffectParameter_DX10.cs" />
     <Compile Include="EffectTechnique_DX10.cs" />
     <Compile Include="Effect_DX10.cs" />
-    <Compile Include="FormatConverter.cs" />
+    <Compile Include="Helpers\FormatConverter.cs" />
     <Compile Include="GraphicsDeviceWindowsDX10.cs" />
-    <Compile Include="IncludeHandler.cs" />
+    <Compile Include="Helpers\IncludeHandler.cs" />
+    <Compile Include="Helpers\WindowHelper.cs" />
     <Compile Include="IndexBuffer_DX10.cs" />
     <Compile Include="EffectPass_DX10.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

RenderSystems/ANX.Framework.Windows.DX10/ANX.RenderSystem.Windows.DX10_Linux.csproj

@@ -82,9 +82,10 @@
     <Compile Include="EffectParameter_DX10.cs" />
     <Compile Include="EffectTechnique_DX10.cs" />
     <Compile Include="Effect_DX10.cs" />
-    <Compile Include="FormatConverter.cs" />
+    <Compile Include="Helpers\FormatConverter.cs" />
     <Compile Include="GraphicsDeviceWindowsDX10.cs" />
-    <Compile Include="IncludeHandler.cs" />
+    <Compile Include="Helpers\IncludeHandler.cs" />
+    <Compile Include="Helpers\WindowHelper.cs" />
     <Compile Include="IndexBuffer_DX10.cs" />
     <Compile Include="EffectPass_DX10.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

RenderSystems/ANX.Framework.Windows.DX10/ANX.RenderSystem.Windows.DX10_PSVita.csproj

@@ -83,9 +83,10 @@
     <Compile Include="EffectParameter_DX10.cs" />
     <Compile Include="EffectTechnique_DX10.cs" />
     <Compile Include="Effect_DX10.cs" />
-    <Compile Include="FormatConverter.cs" />
+    <Compile Include="Helpers\FormatConverter.cs" />
     <Compile Include="GraphicsDeviceWindowsDX10.cs" />
-    <Compile Include="IncludeHandler.cs" />
+    <Compile Include="Helpers\IncludeHandler.cs" />
+    <Compile Include="Helpers\WindowHelper.cs" />
     <Compile Include="IndexBuffer_DX10.cs" />
     <Compile Include="EffectPass_DX10.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

RenderSystems/ANX.Framework.Windows.DX10/ANX.RenderSystem.Windows.DX10_WindowsMetro.csproj

@@ -84,9 +84,10 @@
     <Compile Include="EffectParameter_DX10.cs" />
     <Compile Include="EffectTechnique_DX10.cs" />
     <Compile Include="Effect_DX10.cs" />
-    <Compile Include="FormatConverter.cs" />
+    <Compile Include="Helpers\FormatConverter.cs" />
     <Compile Include="GraphicsDeviceWindowsDX10.cs" />
-    <Compile Include="IncludeHandler.cs" />
+    <Compile Include="Helpers\IncludeHandler.cs" />
+    <Compile Include="Helpers\WindowHelper.cs" />
     <Compile Include="IndexBuffer_DX10.cs" />
     <Compile Include="EffectPass_DX10.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

RenderSystems/ANX.Framework.Windows.DX10/BlendState_DX10.cs

@@ -1,14 +1,8 @@
-#region Using Statements
+using ANX.Framework;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using SharpDX.Direct3D10;
 using ANX.Framework.Graphics;
 using ANX.Framework.NonXNA;
-using ANX.Framework;
+using ANX.RenderSystem.Windows.DX10.Helpers;
-
+using Dx10 = SharpDX.Direct3D10;
-#endregion // Using Statements
 
 // This file is part of the ANX.Framework created by the
 // "ANX.Framework developer group" and released under the Ms-PL license.
@@ -18,236 +12,193 @@ namespace ANX.RenderSystem.Windows.DX10
 {
     public class BlendState_DX10 : INativeBlendState
     {
-        #region Private Members
+		private const float ColorByteToFloatFactor = 1f / 255f;
-        private BlendStateDescription description;
+
-        private SharpDX.Direct3D10.BlendState nativeBlendState;
+        #region Private
-        private bool nativeBlendStateDirty;
+		private Dx10.BlendStateDescription description;
+        private Dx10.BlendState nativeBlendState;
+        private bool isDirty;
         private SharpDX.Color4 blendFactor;
         private int multiSampleMask;
-        private bool bound;
+		#endregion
 
-        #endregion // Private Members
+		#region Public
+		public bool IsBound
+		{
+			get;
+			private set;
+		}
 
-        public BlendState_DX10()
+		public Color BlendFactor
-        {
+		{
-            this.description = new BlendStateDescription();
+			set
+			{
+				blendFactor.Red = value.R * ColorByteToFloatFactor;
+				blendFactor.Green = value.G * ColorByteToFloatFactor;
+				blendFactor.Blue = value.B * ColorByteToFloatFactor;
+				blendFactor.Alpha = value.A * ColorByteToFloatFactor;
+			}
+		}
 
+		public int MultiSampleMask
+		{
+			set
+			{
+				multiSampleMask = value;
+			}
+		}
+
+		public BlendFunction AlphaBlendFunction
+		{
+			set
+			{
+				Dx10.BlendOperation alphaBlendOperation = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.AlphaBlendOperation, ref alphaBlendOperation);
+			}
+		}
+
+		public BlendFunction ColorBlendFunction
+		{
+			set
+			{
+				Dx10.BlendOperation blendOperation = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.BlendOperation, ref blendOperation);
+			}
+		}
+
+		public Blend AlphaDestinationBlend
+		{
+			set
+			{
+				Dx10.BlendOption destinationAlphaBlend = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.DestinationAlphaBlend, ref destinationAlphaBlend);
+			}
+		}
+
+		public Blend ColorDestinationBlend
+		{
+			set
+			{
+				Dx10.BlendOption destinationBlend = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.DestinationBlend, ref destinationBlend);
+			}
+		}
+
+		public ColorWriteChannels ColorWriteChannels
+		{
+			set
+			{
+				Dx10.ColorWriteMaskFlags writeMask = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.RenderTargetWriteMask[0], ref writeMask);
+			}
+		}
+
+		public ColorWriteChannels ColorWriteChannels1
+		{
+			set
+			{
+				Dx10.ColorWriteMaskFlags writeMask = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.RenderTargetWriteMask[1], ref writeMask);
+			}
+		}
+
+		public ColorWriteChannels ColorWriteChannels2
+		{
+			set
+			{
+				Dx10.ColorWriteMaskFlags writeMask = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.RenderTargetWriteMask[2], ref writeMask);
+			}
+		}
+
+		public ColorWriteChannels ColorWriteChannels3
+		{
+			set
+			{
+				Dx10.ColorWriteMaskFlags writeMask = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.RenderTargetWriteMask[3], ref writeMask);
+			}
+		}
+
+		public Blend AlphaSourceBlend
+		{
+			set
+			{
+				Dx10.BlendOption sourceAlphaBlend = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.SourceAlphaBlend, ref sourceAlphaBlend);
+			}
+		}
+
+		public Blend ColorSourceBlend
+		{
+			set
+			{
+				Dx10.BlendOption sourceBlend = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.SourceBlend, ref sourceBlend);
+			}
+		}
+		#endregion
+
+		#region Constructor
+		public BlendState_DX10()
+		{
+			isDirty = true;
             for (int i = 0; i < description.IsBlendEnabled.Length; i++)
-            {
                 description.IsBlendEnabled[i] = (i < 4);
-            }
-
-            nativeBlendStateDirty = true;
         }
+		#endregion
 
-        public void Apply(GraphicsDevice graphics)
+		#region Apply
+		public void Apply(GraphicsDevice graphics)
         {
-            GraphicsDeviceWindowsDX10 gdx10 = graphics.NativeDevice as GraphicsDeviceWindowsDX10;
+            Dx10.Device device = (graphics.NativeDevice as GraphicsDeviceWindowsDX10).NativeDevice;
-            SharpDX.Direct3D10.Device device = gdx10.NativeDevice;
 
             UpdateNativeBlendState(device);
-            this.bound = true;
+			IsBound = true;
 
-            device.OutputMerger.SetBlendState(nativeBlendState, this.blendFactor, this.multiSampleMask);
+            device.OutputMerger.SetBlendState(nativeBlendState, blendFactor, multiSampleMask);
         }
+		#endregion
 
-        public void Release()
+		#region Release
+		public void Release()
         {
-            this.bound = false;
+			IsBound = false;
-        }
+		}
+		#endregion
 
-        public void Dispose()
+		#region Dispose
+		public void Dispose()
         {
-            if (this.nativeBlendState != null)
+            if (nativeBlendState != null)
             {
-                this.nativeBlendState.Dispose();
+                nativeBlendState.Dispose();
-                this.nativeBlendState = null;
+                nativeBlendState = null;
+            }
+		}
+		#endregion
+
+		#region UpdateNativeBlendState
+		private void UpdateNativeBlendState(Dx10.Device device)
+        {
+			if (isDirty || nativeBlendState == null)
+            {
+				Dispose();
+                nativeBlendState = new Dx10.BlendState(device, ref description);
+				isDirty = false;
             }
         }
+		#endregion
 
-        public bool IsBound
+		#region UpdateValueAndMarkDirtyIfNeeded
-        {
+		private void UpdateValueAndMarkDirtyIfNeeded<T>(ref T currentValue, ref T value)
-            get
+		{
-            {
+			if (value.Equals(currentValue) == false)
-                return this.bound;
+			{
-            }
+				isDirty = true;
-        }
+				currentValue = value;
-
+			}
-        public Color BlendFactor
+		}
-        {
+		#endregion
-            set
+	}
-            {
-							const float colorConvert = 1f / 255f;
-
-							blendFactor.Red = value.R * colorConvert;
-							blendFactor.Green = value.G * colorConvert;
-							blendFactor.Blue = value.B * colorConvert;
-							blendFactor.Alpha = value.A * colorConvert;
-            }
-        }
-
-        public int MultiSampleMask
-        {
-            set
-            {
-                this.multiSampleMask = value;
-            }
-        }
-
-        public BlendFunction AlphaBlendFunction
-        {
-            set
-            {
-                BlendOperation alphaBlendOperation = FormatConverter.Translate(value);
-
-                if (description.AlphaBlendOperation != alphaBlendOperation)
-                {
-                    nativeBlendStateDirty = true;
-                    description.AlphaBlendOperation = alphaBlendOperation;
-                }
-            }
-        }
-
-        public BlendFunction ColorBlendFunction
-        {
-            set
-            {
-                BlendOperation blendOperation = FormatConverter.Translate(value);
-
-                if (description.BlendOperation != blendOperation)
-                {
-                    nativeBlendStateDirty = true;
-                    description.BlendOperation = blendOperation;
-                }
-            }
-        }
-
-        public Blend AlphaDestinationBlend
-        {
-            set
-            {
-                BlendOption destinationAlphaBlend = FormatConverter.Translate(value);
-
-                if (description.DestinationAlphaBlend != destinationAlphaBlend)
-                {
-                    nativeBlendStateDirty = true;
-                    description.DestinationAlphaBlend = destinationAlphaBlend;
-                }
-            }
-        }
-
-        public Blend ColorDestinationBlend
-        {
-            set
-            {
-                BlendOption destinationBlend = FormatConverter.Translate(value);
-
-                if (description.DestinationBlend != destinationBlend)
-                {
-                    nativeBlendStateDirty = true;
-                    description.DestinationBlend = destinationBlend;
-                }
-            }
-        }
-
-        public ColorWriteChannels ColorWriteChannels
-        {
-            set
-            {
-                ColorWriteMaskFlags renderTargetWriteMask = FormatConverter.Translate(value);
-
-                if (description.RenderTargetWriteMask[0] != renderTargetWriteMask)
-                {
-                    nativeBlendStateDirty = true;
-                    description.RenderTargetWriteMask[0] = renderTargetWriteMask;
-                }
-            }
-        }
-
-        public ColorWriteChannels ColorWriteChannels1
-        {
-            set
-            {
-                ColorWriteMaskFlags renderTargetWriteMask = FormatConverter.Translate(value);
-
-                if (description.RenderTargetWriteMask[1] != renderTargetWriteMask)
-                {
-                    nativeBlendStateDirty = true;
-                    description.RenderTargetWriteMask[1] = renderTargetWriteMask;
-                }
-            }
-        }
-
-        public ColorWriteChannels ColorWriteChannels2
-        {
-            set
-            {
-                ColorWriteMaskFlags renderTargetWriteMask = FormatConverter.Translate(value);
-
-                if (description.RenderTargetWriteMask[2] != renderTargetWriteMask)
-                {
-                    nativeBlendStateDirty = true;
-                    description.RenderTargetWriteMask[2] = renderTargetWriteMask;
-                }
-            }
-        }
-
-        public ColorWriteChannels ColorWriteChannels3
-        {
-            set
-            {
-                ColorWriteMaskFlags renderTargetWriteMask = FormatConverter.Translate(value);
-
-                if (description.RenderTargetWriteMask[3] != renderTargetWriteMask)
-                {
-                    nativeBlendStateDirty = true;
-                    description.RenderTargetWriteMask[3] = renderTargetWriteMask;
-                }
-            }
-        }
-
-        public Blend AlphaSourceBlend
-        {
-            set
-            {
-                BlendOption sourceAlphaBlend = FormatConverter.Translate(value);
-
-                if (description.SourceAlphaBlend != sourceAlphaBlend)
-                {
-                    nativeBlendStateDirty = true;
-                    description.SourceAlphaBlend = sourceAlphaBlend;
-                }
-            }
-        }
-
-        public Blend ColorSourceBlend
-        {
-            set
-            {
-                BlendOption sourceBlend = FormatConverter.Translate(value);
-
-                if (description.SourceBlend != sourceBlend)
-                {
-                    nativeBlendStateDirty = true;
-                    description.SourceBlend = sourceBlend;
-                }
-            }
-        }
-
-        private void UpdateNativeBlendState(SharpDX.Direct3D10.Device device)
-        {
-            if (this.nativeBlendStateDirty == true || this.nativeBlendState == null)
-            {
-                if (this.nativeBlendState != null)
-                {
-                    this.nativeBlendState.Dispose();
-                    this.nativeBlendState = null;
-                }
-
-                this.nativeBlendState = new SharpDX.Direct3D10.BlendState(device, ref this.description);
-
-                this.nativeBlendStateDirty = false;
-            }
-        }
-    }
 }

RenderSystems/ANX.Framework.Windows.DX10/Creator.cs

@@ -6,8 +6,8 @@ using ANX.Framework;
 using ANX.Framework.Graphics;
 using ANX.Framework.NonXNA;
 using ANX.Framework.NonXNA.RenderSystem;
+using ANX.RenderSystem.Windows.DX10.Helpers;
 using SharpDX.DXGI;
-using Dx10 = SharpDX.Direct3D10;
 
 // This file is part of the ANX.Framework created by the
 // "ANX.Framework developer group" and released under the Ms-PL license.

RenderSystems/ANX.Framework.Windows.DX10/DepthStencilState_DX10.cs

@@ -1,301 +1,236 @@
-#region Using Statements
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using SharpDX.Direct3D10;
 using ANX.Framework.Graphics;
 using ANX.Framework.NonXNA;
-using ANX.Framework;
+using ANX.RenderSystem.Windows.DX10.Helpers;
-
+using Dx10 = SharpDX.Direct3D10;
-#endregion // Using Statements
 
 // This file is part of the ANX.Framework created by the
 // "ANX.Framework developer group" and released under the Ms-PL license.
 // For details see: http://anxframework.codeplex.com/license
 
-using StencilOperation = ANX.Framework.Graphics.StencilOperation;
-
 namespace ANX.RenderSystem.Windows.DX10
 {
     public class DepthStencilState_DX10 : INativeDepthStencilState
     {
-        #region Private Members
+        #region Private
-        private DepthStencilStateDescription description;
+		private Dx10.DepthStencilStateDescription description;
-        private SharpDX.Direct3D10.DepthStencilState nativeDepthStencilState;
+		private Dx10.DepthStencilState nativeDepthStencilState;
-        private bool nativeDepthStencilStateDirty;
+        private bool isDirty;
-        private bool bound;
-
         private int referenceStencil;
+		#endregion
 
-        #endregion // Private Members
+		#region Public (TODO)
+		public bool IsBound
+		{
+			get;
+			private set;
+		}
 
-        public DepthStencilState_DX10()
+		public StencilOperation CounterClockwiseStencilDepthBufferFail
+		{
+			set
+			{
+				Dx10.StencilOperation operation = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.BackFace.DepthFailOperation, ref operation);
+			}
+		}
+
+		public StencilOperation CounterClockwiseStencilFail
+		{
+			set
+			{
+				Dx10.StencilOperation operation = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.BackFace.FailOperation, ref operation);
+			}
+		}
+
+		public CompareFunction CounterClockwiseStencilFunction
+		{
+			set
+			{
+				Dx10.Comparison comparison = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.BackFace.Comparison, ref comparison);
+			}
+		}
+
+		public StencilOperation CounterClockwiseStencilPass
+		{
+			set
+			{
+				Dx10.StencilOperation operation = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.BackFace.PassOperation, ref operation);
+			}
+		}
+
+		public bool DepthBufferEnable
+		{
+			set
+			{
+				if (description.IsDepthEnabled != value)
+				{
+					description.IsDepthEnabled = value;
+					isDirty = true;
+				}
+			}
+		}
+
+		public CompareFunction DepthBufferFunction
+		{
+			set
+			{
+				Dx10.Comparison comparison = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.DepthComparison, ref comparison);
+			}
+		}
+
+		public bool DepthBufferWriteEnable
+		{
+			set
+			{
+				Dx10.DepthWriteMask writeMask = value ? Dx10.DepthWriteMask.All : Dx10.DepthWriteMask.Zero;
+				UpdateValueAndMarkDirtyIfNeeded(ref description.DepthWriteMask, ref writeMask);
+			}
+		}
+
+		public int ReferenceStencil
+		{
+			set
+			{
+				UpdateValueAndMarkDirtyIfNeeded(ref referenceStencil, ref value);
+			}
+		}
+
+		public StencilOperation StencilDepthBufferFail
+		{
+			set
+			{
+				Dx10.StencilOperation operation = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.FrontFace.DepthFailOperation, ref operation);
+			}
+		}
+
+		public bool StencilEnable
+		{
+			set
+			{
+				if (description.IsStencilEnabled != value)
+				{
+					description.IsStencilEnabled = value;
+					isDirty = true;
+				}
+			}
+		}
+
+		public StencilOperation StencilFail
+		{
+			set
+			{
+				Dx10.StencilOperation operation = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.FrontFace.FailOperation, ref operation);
+			}
+		}
+
+		public CompareFunction StencilFunction
+		{
+			set
+			{
+				Dx10.Comparison comparison = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.FrontFace.Comparison, ref comparison);
+			}
+		}
+
+		public int StencilMask
+		{
+			set
+			{
+				byte stencilMask = (byte)value;         //TODO: check range
+				UpdateValueAndMarkDirtyIfNeeded(ref description.StencilReadMask, ref stencilMask);
+			}
+		}
+
+		public StencilOperation StencilPass
+		{
+			set
+			{
+				Dx10.StencilOperation operation = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.FrontFace.PassOperation, ref operation);
+			}
+		}
+
+		public int StencilWriteMask
+		{
+			set
+			{
+				byte stencilWriteMask = (byte)value;        //TODO: check range
+				UpdateValueAndMarkDirtyIfNeeded(ref description.StencilWriteMask, ref stencilWriteMask);
+			}
+		}
+
+		public bool TwoSidedStencilMode
+		{
+			set
+			{
+				//TODO: check if we really need  in xna this enables only counter clockwise stencil operations
+			}
+		}
+		#endregion
+
+		#region Constructor
+		public DepthStencilState_DX10()
         {
-            this.description = new DepthStencilStateDescription();
+            isDirty = true;
-
-            this.nativeDepthStencilStateDirty = true;
         }
-
+		#endregion
+		
+		#region Apply
         public void Apply(GraphicsDevice graphicsDevice)
         {
-            GraphicsDeviceWindowsDX10 gdx10 = graphicsDevice.NativeDevice as GraphicsDeviceWindowsDX10;
+			Dx10.Device device = (graphicsDevice.NativeDevice as GraphicsDeviceWindowsDX10).NativeDevice;
-            Device device = gdx10.NativeDevice;
-
             UpdateNativeDepthStencilState(device);
-            this.bound = true;
+			IsBound = true;
 
-            device.OutputMerger.SetDepthStencilState(nativeDepthStencilState, this.referenceStencil);
+            device.OutputMerger.SetDepthStencilState(nativeDepthStencilState, referenceStencil);
         }
-
+		#endregion
+		
+		#region Release
         public void Release()
         {
-            this.bound = false;
+			IsBound = false;
         }
-
+		#endregion
+		
+		#region Dispose
         public void Dispose()
         {
-            if (this.nativeDepthStencilState != null)
+            if (nativeDepthStencilState != null)
             {
-                this.nativeDepthStencilState.Dispose();
+                nativeDepthStencilState.Dispose();
-                this.nativeDepthStencilState = null;
+                nativeDepthStencilState = null;
             }
         }
+		#endregion
 
-        public bool IsBound
+		#region UpdateNativeDepthStencilState
+		private void UpdateNativeDepthStencilState(Dx10.Device device)
         {
-            get
+            if (isDirty == true || nativeDepthStencilState == null)
             {
-                return this.bound;
+                Dispose();
+                nativeDepthStencilState = new Dx10.DepthStencilState(device, ref description);
+                isDirty = false;
             }
         }
+		#endregion
 
-        public StencilOperation CounterClockwiseStencilDepthBufferFail
+		#region UpdateValueAndMarkDirtyIfNeeded
-        {
+		private void UpdateValueAndMarkDirtyIfNeeded<T>(ref T currentValue, ref T value)
-            set 
+		{
-            {
+			if (value.Equals(currentValue) == false)
-                SharpDX.Direct3D10.StencilOperation operation = FormatConverter.Translate(value);
+			{
-
+				isDirty = true;
-                if (description.BackFace.DepthFailOperation != operation)
+				currentValue = value;
-                {
+			}
-                    description.BackFace.DepthFailOperation = operation;
+		}
-                    nativeDepthStencilStateDirty = true;
+		#endregion
-                }
-            }
-        }
-
-        public StencilOperation CounterClockwiseStencilFail
-        {
-            set 
-            {
-                SharpDX.Direct3D10.StencilOperation operation = FormatConverter.Translate(value);
-
-                if (description.BackFace.FailOperation != operation)
-                {
-                    description.BackFace.FailOperation = operation;
-                    nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public CompareFunction CounterClockwiseStencilFunction
-        {
-            set 
-            {
-                SharpDX.Direct3D10.Comparison comparison = FormatConverter.Translate(value);
-
-                if (description.BackFace.Comparison != comparison)
-                {
-                    description.BackFace.Comparison = comparison;
-                    nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public StencilOperation CounterClockwiseStencilPass
-        {
-            set 
-            {
-                SharpDX.Direct3D10.StencilOperation operation = FormatConverter.Translate(value);
-
-                if (description.BackFace.PassOperation != operation)
-                {
-                    description.BackFace.PassOperation = operation;
-                    nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public bool DepthBufferEnable
-        {
-            set 
-            {
-                if (description.IsDepthEnabled != value)
-                {
-                    description.IsDepthEnabled = value;
-                    nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public CompareFunction DepthBufferFunction
-        {
-            set 
-            {
-                SharpDX.Direct3D10.Comparison comparison = FormatConverter.Translate(value);
-
-                if (description.DepthComparison != comparison)
-                {
-                    description.DepthComparison = comparison;
-                    nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public bool DepthBufferWriteEnable
-        {
-            set 
-            { 
-                DepthWriteMask writeMask = value ? DepthWriteMask.All : DepthWriteMask.Zero;
-
-                if (description.DepthWriteMask != writeMask)
-                {
-                    description.DepthWriteMask = writeMask;
-                    nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public int ReferenceStencil
-        {
-            set 
-            {
-                if (this.referenceStencil != value)
-                {
-                    this.referenceStencil = value;
-                    this.nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public StencilOperation StencilDepthBufferFail
-        {
-            set 
-            {
-                SharpDX.Direct3D10.StencilOperation operation = FormatConverter.Translate(value);
-
-                if (description.FrontFace.DepthFailOperation != operation)
-                {
-                    description.FrontFace.DepthFailOperation = operation;
-                    nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public bool StencilEnable
-        {
-            set 
-            {
-                if (description.IsStencilEnabled != value)
-                {
-                    description.IsStencilEnabled = value;
-                    nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public StencilOperation StencilFail
-        {
-            set
-            {
-                SharpDX.Direct3D10.StencilOperation operation = FormatConverter.Translate(value);
-
-                if (description.FrontFace.FailOperation != operation)
-                {
-                    description.FrontFace.FailOperation = operation;
-                    nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public CompareFunction StencilFunction
-        {
-            set 
-            {
-                SharpDX.Direct3D10.Comparison comparison = FormatConverter.Translate(value);
-
-                if (description.FrontFace.Comparison != comparison)
-                {
-                    description.FrontFace.Comparison = comparison;
-                    nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public int StencilMask
-        {
-            set 
-            {
-                byte stencilMask = (byte)value;         //TODO: check range
-
-                if (description.StencilReadMask != stencilMask)
-                {
-                    description.StencilReadMask = stencilMask;
-                    nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public StencilOperation StencilPass
-        {
-            set 
-            {
-                SharpDX.Direct3D10.StencilOperation operation = FormatConverter.Translate(value);
-
-                if (description.FrontFace.PassOperation != operation)
-                {
-                    description.FrontFace.PassOperation = operation;
-                    nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public int StencilWriteMask
-        {
-            set 
-            {
-                byte stencilWriteMask = (byte)value;        //TODO: check range
-
-                if (description.StencilWriteMask != stencilWriteMask)
-                {
-                    description.StencilWriteMask = stencilWriteMask;
-                    nativeDepthStencilStateDirty = true;
-                }
-            }
-        }
-
-        public bool TwoSidedStencilMode
-        {
-            set 
-            { 
-                //TODO: check if we really need this. in xna this enables only counter clockwise stencil operations
-            }
-        }
-
-        private void UpdateNativeDepthStencilState(Device device)
-        {
-            if (this.nativeDepthStencilStateDirty == true || this.nativeDepthStencilState == null)
-            {
-                if (this.nativeDepthStencilState != null)
-                {
-                    this.nativeDepthStencilState.Dispose();
-                    this.nativeDepthStencilState = null;
-                }
-
-                this.nativeDepthStencilState = new SharpDX.Direct3D10.DepthStencilState(device, ref this.description);
-
-                this.nativeDepthStencilStateDirty = false;
-            }
-        }
     }
 }

RenderSystems/ANX.Framework.Windows.DX10/EffectParameter_DX10.cs

@@ -1,299 +1,278 @@
-#region Using Statements
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using ANX.Framework.NonXNA;
-using SharpDX.Direct3D10;
-using ANX.Framework.Graphics;
-using ANX.Framework.NonXNA.RenderSystem;
 using ANX.Framework;
-
+using ANX.Framework.Graphics;
-#endregion // Using Statements
+using ANX.Framework.NonXNA;
+using Dx10 = SharpDX.Direct3D10;
 
 // This file is part of the ANX.Framework created by the
 // "ANX.Framework developer group" and released under the Ms-PL license.
 // For details see: http://anxframework.codeplex.com/license
 
-using Texture2D = ANX.Framework.Graphics.Texture2D;
-using Texture3D = ANX.Framework.Graphics.Texture3D;
-
 namespace ANX.RenderSystem.Windows.DX10
 {
-    public class EffectParameter_DX10 : INativeEffectParameter
+	public class EffectParameter_DX10 : INativeEffectParameter
-    {
+	{
-        private EffectVariable nativeEffectVariable;
+		#region Public
-
+		public Dx10.EffectVariable NativeParameter
-        public EffectVariable NativeParameter
+		{
-        {
+			get;
-            get
+			internal set;
-            {
-                return this.nativeEffectVariable;
-            }
-            internal set
-            {
-                this.nativeEffectVariable = value;
-            }
-        }
-
-        public void SetValue(bool value)
-        {
-            nativeEffectVariable.AsScalar().Set(value);
-        }
-
-        public void SetValue(bool[] value)
-        {
-            nativeEffectVariable.AsScalar().Set(value);
-        }
-
-        public void SetValue(int value)
-        {
-            nativeEffectVariable.AsScalar().Set(value);
-        }
-
-        public void SetValue(int[] value)
-        {
-            nativeEffectVariable.AsScalar().Set(value);
-        }
-
-        public void SetValue(Matrix value, bool transpose)
-        {
-			// TODO: handle transpose!
-            SharpDX.Matrix m = new SharpDX.Matrix(value.M11, value.M12, value.M13, value.M14, value.M21, value.M22, value.M23, value.M24, value.M31, value.M32, value.M33, value.M34, value.M41, value.M42, value.M43, value.M44);
-            nativeEffectVariable.AsMatrix().SetMatrix(m);
-        }
-
-        public void SetValue(Matrix[] value, bool transpose)
-        {
-			// TODO: handle transpose!
-            int count = value.Length;
-            SharpDX.Matrix[] m = new SharpDX.Matrix[count];
-            Matrix anxMatrix;
-            for (int i = 0; i < count; i++)
-            {
-                anxMatrix = value[i];
-                m[i] = new SharpDX.Matrix(anxMatrix.M11, anxMatrix.M12, anxMatrix.M13, anxMatrix.M14,
-                                          anxMatrix.M21, anxMatrix.M22, anxMatrix.M23, anxMatrix.M24,
-                                          anxMatrix.M31, anxMatrix.M32, anxMatrix.M33, anxMatrix.M34,
-                                          anxMatrix.M41, anxMatrix.M42, anxMatrix.M43, anxMatrix.M44);
-            }
-
-            nativeEffectVariable.AsMatrix().SetMatrix(m);
-        }
-
-        public void SetValue(Quaternion value)
-        {
-            SharpDX.Vector4 q = new SharpDX.Vector4(value.X, value.Y, value.Z, value.W);
-            nativeEffectVariable.AsVector().Set(q);
-        }
-
-        public void SetValue(Quaternion[] value)
-        {
-            int count = value.Length;
-            SharpDX.Vector4[] q = new SharpDX.Vector4[count];
-            for (int i = 0; i < count; i++)
-            {
-                q[i] = new SharpDX.Vector4(value[i].X, value[i].Y, value[i].Z, value[i].W);
-            }
-            nativeEffectVariable.AsVector().Set(q);
-        }
-
-        public void SetValue(float value)
-        {
-            nativeEffectVariable.AsScalar().Set(value);
-        }
-
-        public void SetValue(float[] value)
-        {
-            nativeEffectVariable.AsScalar().Set(value);
-        }
-
-        public void SetValue(Vector2 value)
-        {
-            SharpDX.Vector2 v = new SharpDX.Vector2(value.X, value.Y);
-            nativeEffectVariable.AsVector().Set(v);
-        }
-
-        public void SetValue(Vector2[] value)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void SetValue(Vector3 value)
-        {
-            SharpDX.Vector3 v = new SharpDX.Vector3(value.X, value.Y, value.Z);
-            nativeEffectVariable.AsVector().Set(v);
-        }
-
-        public void SetValue(Vector3[] value)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void SetValue(Vector4 value)
-        {
-            SharpDX.Vector4 v = new SharpDX.Vector4(value.X, value.Y, value.Z, value.W);
-            nativeEffectVariable.AsVector().Set(v);
-        }
-
-        public void SetValue(Vector4[] value)
-        {
-            int count = value.Length;
-            SharpDX.Vector4[] q = new SharpDX.Vector4[count];
-            for (int i = 0; i < count; i++)
-            {
-                q[i] = new SharpDX.Vector4(value[i].X, value[i].Y, value[i].Z, value[i].W);
-            }
-            nativeEffectVariable.AsVector().Set(q);
-        }
-
-        public void SetValue(Texture value)
-        {
-            if (value == null)
-            {
-                throw new ArgumentNullException("value");
-            }
-
-            Texture2D_DX10 tex = value.NativeTexture as Texture2D_DX10;
-            GraphicsDeviceWindowsDX10 graphicsDX10 = tex.GraphicsDevice.NativeDevice as GraphicsDeviceWindowsDX10;
-            SharpDX.Direct3D10.Device device = graphicsDX10.NativeDevice;
-
-            nativeEffectVariable.AsShaderResource().SetResource(tex.NativeShaderResourceView);
-        }
-
-
-
-        public string Name
-        {
-            get 
-            {
-                return nativeEffectVariable.Description.Name;
-            }
-        }
-
-				#region INativeEffectParameter Member
-
-
-				public bool GetValueBoolean()
-				{
-					throw new NotImplementedException();
-				}
-
-				public bool[] GetValueBooleanArray(int count)
-				{
-					throw new NotImplementedException();
-				}
-
-				public int GetValueInt32()
-				{
-					throw new NotImplementedException();
-				}
-
-				public int[] GetValueInt32Array(int count)
-				{
-					throw new NotImplementedException();
-				}
-
-				public Matrix GetValueMatrix()
-				{
-					throw new NotImplementedException();
-				}
-
-				public Matrix[] GetValueMatrixArray(int count)
-				{
-					throw new NotImplementedException();
-				}
-
-				public Matrix GetValueMatrixTranspose()
-				{
-					throw new NotImplementedException();
-				}
-
-				public Matrix[] GetValueMatrixTransposeArray(int count)
-				{
-					throw new NotImplementedException();
-				}
-
-				public Quaternion GetValueQuaternion()
-				{
-					throw new NotImplementedException();
-				}
-
-				public Quaternion[] GetValueQuaternionArray(int count)
-				{
-					throw new NotImplementedException();
-				}
-
-				public float GetValueSingle()
-				{
-					throw new NotImplementedException();
-				}
-
-				public float[] GetValueSingleArray(int count)
-				{
-					throw new NotImplementedException();
-				}
-
-				public string GetValueString()
-				{
-					throw new NotImplementedException();
-				}
-
-				public Texture2D GetValueTexture2D()
-				{
-					throw new NotImplementedException();
-				}
-
-				public Texture3D GetValueTexture3D()
-				{
-					throw new NotImplementedException();
-				}
-
-				public TextureCube GetValueTextureCube()
-				{
-					throw new NotImplementedException();
-				}
-
-				public Vector2 GetValueVector2()
-				{
-					throw new NotImplementedException();
-				}
-
-				public Vector2[] GetValueVector2Array(int count)
-				{
-					throw new NotImplementedException();
-				}
-
-				public Vector3 GetValueVector3()
-				{
-					throw new NotImplementedException();
-				}
-
-				public Vector3[] GetValueVector3Array(int count)
-				{
-					throw new NotImplementedException();
-				}
-
-				public Vector4 GetValueVector4()
-				{
-					throw new NotImplementedException();
-				}
-
-				public Vector4[] GetValueVector4Array(int count)
-				{
-					throw new NotImplementedException();
-				}
-
-				#endregion
-
-				#region INativeEffectParameter Member
-
-
-				public void SetValue(string value)
-				{
-					throw new NotImplementedException();
-				}
-
-				#endregion
 		}
+
+		public string Name
+		{
+			get
+			{
+				return NativeParameter.Description.Name;
+			}
+		}
+		#endregion
+
+		#region SetValue (bool)
+		public void SetValue(bool value)
+		{
+			NativeParameter.AsScalar().Set(value);
+		}
+		#endregion
+
+		#region SetValue (bool[])
+		public void SetValue(bool[] value)
+		{
+			NativeParameter.AsScalar().Set(value);
+		}
+		#endregion
+
+		#region SetValue (int)
+		public void SetValue(int value)
+		{
+			NativeParameter.AsScalar().Set(value);
+		}
+		#endregion
+
+		#region SetValue (int[])
+		public void SetValue(int[] value)
+		{
+			NativeParameter.AsScalar().Set(value);
+		}
+		#endregion
+
+		#region SetValue (Matrix, transpose) (TODO)
+		public void SetValue(Matrix value, bool transpose)
+		{
+			// TODO: handle transpose!
+			NativeParameter.AsMatrix().SetMatrix(value);
+		}
+		#endregion
+
+		#region SetValue (Matrix[], transpose) (TODO)
+		public void SetValue(Matrix[] value, bool transpose)
+		{
+			// TODO: handle transpose!
+			NativeParameter.AsMatrix().SetMatrix(value);
+		}
+		#endregion
+
+		#region SetValue (Quaternion)
+		public void SetValue(Quaternion value)
+		{
+			NativeParameter.AsVector().Set(value);
+		}
+		#endregion
+
+		#region SetValue (Quaternion[])
+		public void SetValue(Quaternion[] value)
+		{
+			NativeParameter.AsVector().Set(value);
+		}
+		#endregion
+
+		#region SetValue (float)
+		public void SetValue(float value)
+		{
+			NativeParameter.AsScalar().Set(value);
+		}
+		#endregion
+
+		#region SetValue (float[])
+		public void SetValue(float[] value)
+		{
+			NativeParameter.AsScalar().Set(value);
+		}
+		#endregion
+
+		#region SetValue (Vector2)
+		public void SetValue(Vector2 value)
+		{
+			NativeParameter.AsVector().Set(value);
+		}
+		#endregion
+
+		#region SetValue (Vector2[])
+		public void SetValue(Vector2[] value)
+		{
+			NativeParameter.AsVector().Set(value);
+		}
+		#endregion
+
+		#region SetValue (Vector3)
+		public void SetValue(Vector3 value)
+		{
+			NativeParameter.AsVector().Set(value);
+		}
+		#endregion
+
+		#region SetValue (Vector3[])
+		public void SetValue(Vector3[] value)
+		{
+			NativeParameter.AsVector().Set(value);
+		}
+		#endregion
+
+		#region SetValue (Vector4)
+		public void SetValue(Vector4 value)
+		{
+			NativeParameter.AsVector().Set(value);
+		}
+		#endregion
+
+		#region SetValue (Vector4[])
+		public void SetValue(Vector4[] value)
+		{
+			NativeParameter.AsVector().Set(value);
+		}
+		#endregion
+
+		#region SetValue (Texture)
+		public void SetValue(Texture value)
+		{
+			if (value == null)
+				throw new ArgumentNullException("value");
+
+			var tex = value.NativeTexture as Texture2D_DX10;
+			var graphicsDX10 = tex.GraphicsDevice.NativeDevice as GraphicsDeviceWindowsDX10;
+			Dx10.Device device = graphicsDX10.NativeDevice;
+
+			NativeParameter.AsShaderResource().SetResource(tex.NativeShaderResourceView);
+		}
+		#endregion
+
+		#region SetValue (string) (TODO)
+		public void SetValue(string value)
+		{
+			throw new NotImplementedException();
+		}
+		#endregion
+
+		#region Get (TODO)
+		public bool GetValueBoolean()
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool[] GetValueBooleanArray(int count)
+		{
+			throw new NotImplementedException();
+		}
+
+		public int GetValueInt32()
+		{
+			throw new NotImplementedException();
+		}
+
+		public int[] GetValueInt32Array(int count)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Matrix GetValueMatrix()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Matrix[] GetValueMatrixArray(int count)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Matrix GetValueMatrixTranspose()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Matrix[] GetValueMatrixTransposeArray(int count)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Quaternion GetValueQuaternion()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Quaternion[] GetValueQuaternionArray(int count)
+		{
+			throw new NotImplementedException();
+		}
+
+		public float GetValueSingle()
+		{
+			throw new NotImplementedException();
+		}
+
+		public float[] GetValueSingleArray(int count)
+		{
+			throw new NotImplementedException();
+		}
+
+		public string GetValueString()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Texture2D GetValueTexture2D()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Texture3D GetValueTexture3D()
+		{
+			throw new NotImplementedException();
+		}
+
+		public TextureCube GetValueTextureCube()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Vector2 GetValueVector2()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Vector2[] GetValueVector2Array(int count)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Vector3 GetValueVector3()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Vector3[] GetValueVector3Array(int count)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Vector4 GetValueVector4()
+		{
+			throw new NotImplementedException();
+		}
+
+		public Vector4[] GetValueVector4Array(int count)
+		{
+			throw new NotImplementedException();
+		}
+		#endregion
+	}
 }

RenderSystems/ANX.Framework.Windows.DX10/Effect_DX10.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.IO;
 using ANX.Framework.Graphics;
 using ANX.Framework.NonXNA;
+using ANX.RenderSystem.Windows.DX10.Helpers;
 using SharpDX.D3DCompiler;
 using Dx10 = SharpDX.Direct3D10;
 
@@ -92,35 +93,46 @@ namespace ANX.RenderSystem.Windows.DX10
         }
 		#endregion
 
+		#region GetCurrentTechnique
 		public EffectTechnique_DX10 GetCurrentTechnique()
 		{
 			return managedEffect.CurrentTechnique.NativeTechnique as EffectTechnique_DX10;
 		}
+		#endregion
 
+		#region Apply
 		public void Apply(GraphicsDevice graphicsDevice)
         {
             ((GraphicsDeviceWindowsDX10)graphicsDevice.NativeDevice).currentEffect = this;
         }
+		#endregion
 
-        public static byte[] CompileVertexShader(string effectCode, string directory = "")
+		#region CompileVertexShader (TODO)
+		public static byte[] CompileVertexShader(string effectCode, string directory = "")
         {
+			// TODO: not all entry points are named VS!
             ShaderBytecode vertexShaderByteCode = ShaderBytecode.Compile(effectCode, "VS", "vs_4_0", ShaderFlags.None,
 				EffectFlags.None, null, new IncludeHandler(directory), "unknown");
             byte[] bytecode = new byte[vertexShaderByteCode.BufferSize];
             vertexShaderByteCode.Data.Read(bytecode, 0, bytecode.Length);
             return bytecode;
-        }
+		}
+		#endregion
 
-        public static byte[] CompilePixelShader(string effectCode, string directory = "")
+		#region CompilePixelShader (TODO)
-        {
+		public static byte[] CompilePixelShader(string effectCode, string directory = "")
+		{
+			// TODO: not all entry points are named PS!
             ShaderBytecode pixelShaderByteCode = ShaderBytecode.Compile(effectCode, "PS", "ps_4_0", ShaderFlags.None,
 				EffectFlags.None, null, new IncludeHandler(directory), "unknown");
             byte[] bytecode = new byte[pixelShaderByteCode.BufferSize];
             pixelShaderByteCode.Data.Read(bytecode, 0, bytecode.Length);
             return bytecode;
-        }
+		}
+		#endregion
 
-        public static byte[] CompileFXShader(string effectCode, string directory = "")
+		#region CompileFXShader
+		public static byte[] CompileFXShader(string effectCode, string directory = "")
         {
             ShaderBytecode effectByteCode = ShaderBytecode.Compile(effectCode, "fx_4_0", ShaderFlags.None, EffectFlags.None,
 				null, new IncludeHandler(directory), "unknown");
@@ -128,6 +140,7 @@ namespace ANX.RenderSystem.Windows.DX10
             effectByteCode.Data.Read(bytecode, 0, bytecode.Length);
             return bytecode;
         }
+		#endregion
 
 		#region Dispose
 		public void Dispose()

RenderSystems/ANX.Framework.Windows.DX10/FormatConverter.cs

@@ -1,345 +0,0 @@
-#region Using Statements
-using System;
-using ANX.Framework.Graphics;
-using SharpDX.Direct3D10;
-using SharpDX.Direct3D;
-using SharpDX.DXGI;
-
-#endregion // Using Statements
-
-// This file is part of the ANX.Framework created by the
-// "ANX.Framework developer group" and released under the Ms-PL license.
-// For details see: http://anxframework.codeplex.com/license
-
-using TextureAddressMode = ANX.Framework.Graphics.TextureAddressMode;
-using StencilOperation = ANX.Framework.Graphics.StencilOperation;
-using CullMode = ANX.Framework.Graphics.CullMode;
-using FillMode = ANX.Framework.Graphics.FillMode;
-
-namespace ANX.RenderSystem.Windows.DX10
-{
-    internal class FormatConverter
-    {
-
-        public static int FormatSize(SurfaceFormat format)
-        {
-            switch (format)
-            {
-                case SurfaceFormat.Vector4:
-                    return 16;
-                //case SurfaceFormat.Vector3:
-                //    return 12;
-                case SurfaceFormat.Vector2:
-                    return 8;
-                case SurfaceFormat.Single:
-                case SurfaceFormat.Color:
-                    //case SurfaceFormat.RGBA1010102:
-                    //case SurfaceFormat.RG32:
-                    return 4;
-                //case SurfaceFormat.BGR565:
-                //case SurfaceFormat.BGRA5551:
-                //    return 2;
-                case SurfaceFormat.Dxt1:
-                case SurfaceFormat.Dxt3:
-                case SurfaceFormat.Dxt5:
-                case SurfaceFormat.Alpha8:
-                    return 1;
-                default:
-                    throw new ArgumentException("Invalid format");
-            }
-        }
-        
-        public static SharpDX.DXGI.Format Translate(SurfaceFormat surfaceFormat)
-        {
-            switch (surfaceFormat)
-            {
-                case SurfaceFormat.Color:
-                    return SharpDX.DXGI.Format.R8G8B8A8_UNorm;
-                case SurfaceFormat.Dxt3:
-                    return SharpDX.DXGI.Format.BC2_UNorm;
-                case SurfaceFormat.Dxt5:
-                    return SharpDX.DXGI.Format.BC3_UNorm;
-            }
-
-            throw new Exception("can't translate SurfaceFormat: " + surfaceFormat.ToString());
-        }
-
-        public static Format Translate(ANX.Framework.Graphics.DepthFormat depthFormat)
-        {
-            switch (depthFormat)
-            {
-                case DepthFormat.Depth16:
-                    return Format.D16_UNorm;
-                case DepthFormat.Depth24:
-                    //TODO: no DirectX10 24Bit depth format???                    
-                case DepthFormat.Depth24Stencil8:
-                    return Format.D24_UNorm_S8_UInt;
-                case DepthFormat.None:
-                    return Format.Unknown;
-            }
-
-            throw new Exception("can't translate DepthFormat: " + depthFormat.ToString());
-        }
-
-        public static SurfaceFormat Translate(SharpDX.DXGI.Format format)
-        {
-            switch (format)
-            {
-                case SharpDX.DXGI.Format.R8G8B8A8_UNorm:
-                    return SurfaceFormat.Color;
-                case SharpDX.DXGI.Format.BC2_UNorm:
-                    return SurfaceFormat.Dxt3;
-                case SharpDX.DXGI.Format.BC3_UNorm:
-                    return SurfaceFormat.Dxt5;
-            }
-
-            throw new Exception("can't translate Format: " + format.ToString());
-        }
-
-        public static Filter Translate(TextureFilter filter)
-        {
-            switch (filter)
-            {
-                case TextureFilter.Anisotropic:
-                    return Filter.Anisotropic;
-                case TextureFilter.Linear:
-                    return Filter.MinMagMipLinear;
-                case TextureFilter.LinearMipPoint:
-                    return Filter.MinMagMipPoint;
-                case TextureFilter.MinLinearMagPointMipLinear:
-                    return Filter.MinLinearMagPointMipLinear;
-                case TextureFilter.MinLinearMagPointMipPoint:
-                    return Filter.MinLinearMagMipPoint;
-                case TextureFilter.MinPointMagLinearMipLinear:
-                    return Filter.MinPointMagMipLinear;
-                case TextureFilter.MinPointMagLinearMipPoint:
-                    return Filter.MinPointMagLinearMipPoint;
-                case TextureFilter.Point:
-                    return Filter.MinMagMipPoint;
-                case TextureFilter.PointMipLinear:
-                    return Filter.MinMagPointMipLinear;
-            }
-
-            throw new NotImplementedException();
-        }
-
-        public static SharpDX.Direct3D10.TextureAddressMode Translate(ANX.Framework.Graphics.TextureAddressMode addressMode)
-        {
-            switch (addressMode)
-            {
-                case TextureAddressMode.Clamp:
-                    return SharpDX.Direct3D10.TextureAddressMode.Clamp;
-                case TextureAddressMode.Mirror:
-                    return SharpDX.Direct3D10.TextureAddressMode.Mirror;
-                case TextureAddressMode.Wrap:
-                    return SharpDX.Direct3D10.TextureAddressMode.Wrap;
-            }
-
-            return SharpDX.Direct3D10.TextureAddressMode.Clamp;
-        }
-
-        public static PrimitiveTopology Translate(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;
-                default:
-                    throw new InvalidOperationException("unknown PrimitiveType: " + primitiveType.ToString());
-            }
-        }
-
-        public static SharpDX.DXGI.Format Translate(IndexElementSize indexElementSize)
-        {
-            switch (indexElementSize)
-            {
-                case IndexElementSize.SixteenBits:
-                    return Format.R16_UInt;
-                case IndexElementSize.ThirtyTwoBits:
-                    return Format.R32_UInt;
-                default:
-                    throw new InvalidOperationException("unknown IndexElementSize: " + indexElementSize.ToString());
-            }
-        }
-
-        public static string Translate(ref VertexElement element)
-        {
-            //TODO: map the other Usages
-			if (element.VertexElementUsage == VertexElementUsage.TextureCoordinate)
-				return "TEXCOORD";
-            else
-				return element.VertexElementUsage.ToString().ToUpperInvariant();
-        }
-
-        public static BlendOperation Translate(BlendFunction blendFunction)
-        {
-            switch (blendFunction)
-            {
-                case BlendFunction.Add:
-                    return BlendOperation.Add;
-                case BlendFunction.Max:
-                    return BlendOperation.Maximum;
-                case BlendFunction.Min:
-                    return BlendOperation.Minimum;
-                case BlendFunction.ReverseSubtract:
-                    return BlendOperation.ReverseSubtract;
-                case BlendFunction.Subtract:
-                    return BlendOperation.Subtract;
-            }
-
-            throw new NotImplementedException();
-        }
-
-        public static BlendOption Translate(Blend blend)
-        {
-            switch (blend)
-            {
-                case Blend.BlendFactor:
-                    return BlendOption.BlendFactor;
-                case Blend.DestinationAlpha:
-                    return BlendOption.DestinationAlpha;
-                case Blend.DestinationColor:
-                    return BlendOption.DestinationColor;
-                case Blend.InverseBlendFactor:
-                    return BlendOption.InverseBlendFactor;
-                case Blend.InverseDestinationAlpha:
-                    return BlendOption.InverseDestinationAlpha;
-                case Blend.InverseDestinationColor:
-                    return BlendOption.InverseDestinationColor;
-                case Blend.InverseSourceAlpha:
-                    return BlendOption.InverseSourceAlpha;
-                case Blend.InverseSourceColor:
-                    return BlendOption.InverseSourceColor;
-                case Blend.One:
-                    return BlendOption.One;
-                case Blend.SourceAlpha:
-                    return BlendOption.SourceAlpha;
-                case Blend.SourceAlphaSaturation:
-                    return BlendOption.SourceAlphaSaturate;
-                case Blend.SourceColor:
-                    return BlendOption.SourceColor;
-                case Blend.Zero:
-                    return BlendOption.Zero;
-            }
-
-            throw new NotImplementedException();
-        }
-
-        public static ColorWriteMaskFlags Translate(ColorWriteChannels colorWriteChannels)
-        {
-            ColorWriteMaskFlags mask = 0;
-
-            if ((colorWriteChannels & ColorWriteChannels.All) == ColorWriteChannels.All)
-            {
-                mask |= ColorWriteMaskFlags.All;
-            }
-
-            if ((colorWriteChannels & ColorWriteChannels.Alpha) == ColorWriteChannels.Alpha)
-            {
-                mask |= ColorWriteMaskFlags.Alpha;
-            }
-
-            if ((colorWriteChannels & ColorWriteChannels.Blue) == ColorWriteChannels.Blue)
-            {
-                mask |= ColorWriteMaskFlags.Blue;
-            }
-
-            if ((colorWriteChannels & ColorWriteChannels.Green) == ColorWriteChannels.Green)
-            {
-                mask |= ColorWriteMaskFlags.Green;
-            }
-
-            if ((colorWriteChannels & ColorWriteChannels.Red) == ColorWriteChannels.Red)
-            {
-                mask |= ColorWriteMaskFlags.Red;
-            }
-
-            return mask;
-        }
-
-        public static SharpDX.Direct3D10.StencilOperation Translate(ANX.Framework.Graphics.StencilOperation stencilOperation)
-        {
-            switch (stencilOperation)
-            {
-                case StencilOperation.Decrement:
-                    return SharpDX.Direct3D10.StencilOperation.Decrement;
-                case StencilOperation.DecrementSaturation:
-                    return SharpDX.Direct3D10.StencilOperation.DecrementAndClamp;
-                case StencilOperation.Increment:
-                    return SharpDX.Direct3D10.StencilOperation.Increment;
-                case StencilOperation.IncrementSaturation:
-                    return SharpDX.Direct3D10.StencilOperation.IncrementAndClamp;
-                case StencilOperation.Invert:
-                    return SharpDX.Direct3D10.StencilOperation.Invert;
-                case StencilOperation.Keep:
-                    return SharpDX.Direct3D10.StencilOperation.Keep;
-                case StencilOperation.Replace:
-                    return SharpDX.Direct3D10.StencilOperation.Replace;
-                case StencilOperation.Zero:
-                    return SharpDX.Direct3D10.StencilOperation.Zero;
-            }
-
-            throw new NotImplementedException("unknown StencilOperation");
-        }
-
-        public static Comparison Translate(ANX.Framework.Graphics.CompareFunction compareFunction)
-        {
-            switch (compareFunction)
-            {
-                case ANX.Framework.Graphics.CompareFunction.Always:
-                    return Comparison.Always;
-                case ANX.Framework.Graphics.CompareFunction.Equal:
-                    return Comparison.Equal;
-                case ANX.Framework.Graphics.CompareFunction.Greater:
-                    return Comparison.Greater;
-                case ANX.Framework.Graphics.CompareFunction.GreaterEqual:
-                    return Comparison.GreaterEqual;
-                case ANX.Framework.Graphics.CompareFunction.Less:
-                    return Comparison.Less;
-                case ANX.Framework.Graphics.CompareFunction.LessEqual:
-                    return Comparison.LessEqual;
-                case ANX.Framework.Graphics.CompareFunction.Never:
-                    return Comparison.Never;
-                case ANX.Framework.Graphics.CompareFunction.NotEqual:
-                    return Comparison.NotEqual;
-            }
-
-            throw new NotImplementedException("unknown CompareFunction");
-        }
-
-        public static SharpDX.Direct3D10.CullMode Translate(CullMode cullMode)
-        {
-            if (cullMode == CullMode.CullClockwiseFace)
-            {
-                return SharpDX.Direct3D10.CullMode.Front;
-            }
-            else if (cullMode == CullMode.CullCounterClockwiseFace)
-            {
-                return SharpDX.Direct3D10.CullMode.Back;
-            }
-            else
-            {
-                return SharpDX.Direct3D10.CullMode.None;
-            }
-        }
-
-        public static SharpDX.Direct3D10.FillMode Translate(FillMode fillMode)
-        {
-            if (fillMode == FillMode.WireFrame)
-            {
-                return SharpDX.Direct3D10.FillMode.Wireframe;
-            }
-            else
-            {
-                return SharpDX.Direct3D10.FillMode.Solid;
-            }
-        }
-
-    }
-}

RenderSystems/ANX.Framework.Windows.DX10/GraphicsDeviceWindowsDX10.cs

@@ -1,25 +1,16 @@
-#region Using Statements
 using System;
-using SharpDX.DXGI;
-using SharpDX.D3DCompiler;
-using SharpDX.Direct3D10;
 using ANX.Framework;
-using ANX.Framework.NonXNA;
 using ANX.Framework.Graphics;
-using System.Runtime.InteropServices;
+using ANX.Framework.NonXNA;
-
+using ANX.RenderSystem.Windows.DX10.Helpers;
-#endregion // Using Statements
+using SharpDX.D3DCompiler;
+using SharpDX.DXGI;
+using Dx10 = SharpDX.Direct3D10;
 
 // This file is part of the ANX.Framework created by the
 // "ANX.Framework developer group" and released under the Ms-PL license.
 // For details see: http://anxframework.codeplex.com/license
 
-using Device = SharpDX.Direct3D10.Device;
-using Rectangle = ANX.Framework.Rectangle;
-using Vector4 = ANX.Framework.Vector4;
-using VertexBufferBinding = ANX.Framework.Graphics.VertexBufferBinding;
-using Viewport = ANX.Framework.Graphics.Viewport;
-
 namespace ANX.RenderSystem.Windows.DX10
 {
     public class GraphicsDeviceWindowsDX10 : INativeGraphicsDevice
@@ -28,48 +19,24 @@ namespace ANX.RenderSystem.Windows.DX10
 		private const float ColorMultiplier = 1f / 255f;
 		#endregion
 
-        #region Interop
+        #region Private
-        [DllImport("user32.dll")]
+		private Dx10.Device device;
-        private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int width, int height, uint uFlags);
+        private SwapChain swapChain;
-
+		private Dx10.RenderTargetView renderView;
-        [DllImport("user32.dll")]
+		private Dx10.RenderTargetView[] renderTargetView = new Dx10.RenderTargetView[1];
-        [return: MarshalAs(UnmanagedType.Bool)]
+		private Dx10.DepthStencilView depthStencilView;
-        static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
+        private Dx10.Texture2D depthStencilBuffer;
-
+        private Dx10.Texture2D backBuffer;
-        [DllImport("user32.dll")]
-        [return: MarshalAs(UnmanagedType.Bool)]
-        static extern bool GetClientRect(IntPtr hWnd, out RECT lpRect);
-
-        [StructLayout(LayoutKind.Sequential)]
-        public struct RECT
-        {
-            public int Left;        // x position of upper-left corner 
-            public int Top;         // y position of upper-left corner 
-            public int Right;       // x position of lower-right corner 
-            public int Bottom;      // y position of lower-right corner 
-        } 
-
-        #endregion
-
-        #region Private Members
-        private Device device;
-        private SwapChain swapChain; 
-        private RenderTargetView renderView;
-        private RenderTargetView[] renderTargetView = new RenderTargetView[1];
-        private DepthStencilView depthStencilView;
-        private SharpDX.Direct3D10.Texture2D depthStencilBuffer;
-        private SharpDX.Direct3D10.Texture2D backBuffer;
         internal Effect_DX10 currentEffect;
         private VertexBuffer currentVertexBuffer;
         private IndexBuffer currentIndexBuffer;
-        private SharpDX.Direct3D10.Viewport currentViewport;
+        private Dx10.Viewport currentViewport;
         private uint lastClearColor;
         private SharpDX.Color4 clearColor;
-        private bool vSyncEnabled;
+		#endregion
 
-		#endregion // Private Members
+		#region Public
-
+		internal Dx10.Device NativeDevice
-		internal Device NativeDevice
 		{
 			get
 			{
@@ -77,15 +44,21 @@ namespace ANX.RenderSystem.Windows.DX10
 			}
 		}
 
-        public GraphicsDeviceWindowsDX10(PresentationParameters presentationParameters)
+		public bool VSync { get; set; }
+		#endregion
+
+		#region Constructor
+		public GraphicsDeviceWindowsDX10(PresentationParameters presentationParameters)
         {
-            this.vSyncEnabled = true;
+			VSync = true;
 
             // SwapChain description
             var desc = new SwapChainDescription()
             {
                 BufferCount = 1,
-                ModeDescription = new ModeDescription(presentationParameters.BackBufferWidth, presentationParameters.BackBufferHeight, new Rational(60, 1), FormatConverter.Translate(presentationParameters.BackBufferFormat)),
+                ModeDescription = new ModeDescription(presentationParameters.BackBufferWidth,
+					presentationParameters.BackBufferHeight, new Rational(60, 1),
+					FormatConverter.Translate(presentationParameters.BackBufferFormat)),
                 IsWindowed = true,
                 OutputHandle = presentationParameters.DeviceWindowHandle,
                 SampleDescription = new SampleDescription(1, 0),
@@ -96,34 +69,36 @@ namespace ANX.RenderSystem.Windows.DX10
             // Create Device and SwapChain
 #if DIRECTX_DEBUG_LAYER
             // http://msdn.microsoft.com/en-us/library/windows/desktop/bb205068(v=vs.85).aspx
-            Device.CreateWithSwapChain(SharpDX.Direct3D10.DriverType.Hardware, DeviceCreationFlags.Debug, desc, out device, out swapChain);
+            Dx10.Device.CreateWithSwapChain(Dx10.DriverType.Hardware, Dx10.DeviceCreationFlags.Debug, desc, out device,
+				out swapChain);
 #else
-            Device.CreateWithSwapChain(SharpDX.Direct3D10.DriverType.Hardware, DeviceCreationFlags.None, desc, out device, out swapChain);
+			Dx10.Device.CreateWithSwapChain(Dx10.DriverType.Hardware, Dx10.DeviceCreationFlags.None, desc, out device,
+				out swapChain);
 #endif
 
             // Ignore all windows events
             Factory factory = swapChain.GetParent<Factory>();
             factory.MakeWindowAssociation(presentationParameters.DeviceWindowHandle, WindowAssociationFlags.IgnoreAll);
 
-            ResizeRenderWindow(presentationParameters);
+			WindowHelper.ResizeRenderWindow(presentationParameters);
 
             // New RenderTargetView from the backbuffer
-            backBuffer = SharpDX.Direct3D10.Texture2D.FromSwapChain<SharpDX.Direct3D10.Texture2D>(swapChain, 0);
+            backBuffer = Dx10.Texture2D.FromSwapChain<Dx10.Texture2D>(swapChain, 0);
-            renderView = new RenderTargetView(device, backBuffer);
+			renderView = new Dx10.RenderTargetView(device, backBuffer);
 
-            currentViewport = new SharpDX.Direct3D10.Viewport(0, 0, presentationParameters.BackBufferWidth, presentationParameters.BackBufferHeight);
+            currentViewport = new Dx10.Viewport(0, 0, presentationParameters.BackBufferWidth, presentationParameters.BackBufferHeight);
 
             //
             // create the depth stencil buffer
             //
             Format depthFormat = FormatConverter.Translate(presentationParameters.DepthStencilFormat);
             if (depthFormat != Format.Unknown)
-            {
                 CreateDepthStencilBuffer(depthFormat);
-            }
         }
+		#endregion
 
-        private void CreateDepthStencilBuffer(Format depthFormat)
+		#region CreateDepthStencilBuffer
+		private void CreateDepthStencilBuffer(Format depthFormat)
         {
             if (this.depthStencilBuffer != null &&
                 this.depthStencilBuffer.Description.Format == depthFormat &&
@@ -152,12 +127,12 @@ namespace ANX.RenderSystem.Windows.DX10
                 return;
             }
 
-            DepthStencilViewDescription depthStencilViewDesc = new DepthStencilViewDescription()
+			var depthStencilViewDesc = new Dx10.DepthStencilViewDescription()
             {
                 Format = depthFormat,
             };
 
-            Texture2DDescription depthStencilTextureDesc = new Texture2DDescription()
+			var depthStencilTextureDesc = new Dx10.Texture2DDescription()
             {
                 Width = this.backBuffer.Description.Width,
                 Height = this.backBuffer.Description.Height,
@@ -165,17 +140,19 @@ namespace ANX.RenderSystem.Windows.DX10
                 ArraySize = 1,
                 Format = depthFormat,
                 SampleDescription = new SampleDescription(1, 0),
-                Usage = ResourceUsage.Default,
+				Usage = Dx10.ResourceUsage.Default,
-                BindFlags = BindFlags.DepthStencil,
+				BindFlags = Dx10.BindFlags.DepthStencil,
-                CpuAccessFlags = CpuAccessFlags.None,
+				CpuAccessFlags = Dx10.CpuAccessFlags.None,
-                OptionFlags = ResourceOptionFlags.None
+				OptionFlags = Dx10.ResourceOptionFlags.None
             };
-            this.depthStencilBuffer = new SharpDX.Direct3D10.Texture2D(device, depthStencilTextureDesc);
+            this.depthStencilBuffer = new Dx10.Texture2D(device, depthStencilTextureDesc);
 
-            this.depthStencilView = new DepthStencilView(device, this.depthStencilBuffer);
+			this.depthStencilView = new Dx10.DepthStencilView(device, this.depthStencilBuffer);
 
-            Clear(ClearOptions.DepthBuffer | ClearOptions.Stencil, Vector4.Zero, 1.0f, 0);  // this workaround is working but maybe not the best solution to issue #472
+			// this workaround is working but maybe not the best solution to issue #472
+            Clear(ClearOptions.DepthBuffer | ClearOptions.Stencil, Vector4.Zero, 1.0f, 0);
         }
+		#endregion
 
 		#region Clear
 		public void Clear(ref Color color)
@@ -243,122 +220,117 @@ namespace ANX.RenderSystem.Windows.DX10
                 if ((options | ClearOptions.Stencil | ClearOptions.DepthBuffer) == options)
                 {
                     // Clear the stencil buffer
-                    device.ClearDepthStencilView(this.depthStencilView, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, depth, (byte)stencil);
+					device.ClearDepthStencilView(this.depthStencilView, Dx10.DepthStencilClearFlags.Depth |
+						Dx10.DepthStencilClearFlags.Stencil, depth, (byte)stencil);
                 }
                 else if ((options | ClearOptions.Stencil) == options)
                 {
-                    device.ClearDepthStencilView(this.depthStencilView, DepthStencilClearFlags.Stencil, depth, (byte)stencil);
+					device.ClearDepthStencilView(this.depthStencilView, Dx10.DepthStencilClearFlags.Stencil, depth,
+						(byte)stencil);
                 }
                 else
                 {
-                    device.ClearDepthStencilView(this.depthStencilView, DepthStencilClearFlags.Depth, depth, (byte)stencil);
+					device.ClearDepthStencilView(this.depthStencilView, Dx10.DepthStencilClearFlags.Depth, depth, (byte)stencil);
                 }
             }
         }
-
 		#endregion
 
         #region Present
         public void Present()
         {
-            swapChain.Present(this.vSyncEnabled ? 1 : 0, PresentFlags.None);
+			swapChain.Present(VSync ? 1 : 0, PresentFlags.None);
         }
+        #endregion
 
-        #endregion // Present
+        #region DrawIndexedPrimitives
+        public void DrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int minVertexIndex, int numVertices,
+			int startIndex, int primitiveCount)
+		{
+			Dx10.EffectTechnique technique = SetupEffectForDraw();
+			int vertexCount = FormatConverter.CalculateVertexCount(primitiveType, primitiveCount);
 
-        #region DrawPrimitives & DrawIndexedPrimitives
-        public void DrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int minVertexIndex, int numVertices, int startIndex, int primitiveCount)
-        {
-            SharpDX.Direct3D10.EffectPass pass; SharpDX.Direct3D10.EffectTechnique technique; ShaderBytecode passSignature;
-            SetupEffectForDraw(out pass, out technique, out passSignature);
-
-            SetupInputLayout(passSignature);
-
-            // Prepare All the stages
             device.InputAssembler.PrimitiveTopology = FormatConverter.Translate(primitiveType);
             device.Rasterizer.SetViewports(currentViewport);
-
             device.OutputMerger.SetTargets(this.depthStencilView, this.renderView);
 
             for (int i = 0; i < technique.Description.PassCount; ++i)
-            {
+			{
-                pass.Apply();
+                technique.GetPassByIndex(i).Apply();
-                device.DrawIndexed(CalculateVertexCount(primitiveType, primitiveCount), startIndex, baseVertex);
+				device.DrawIndexed(vertexCount, startIndex, baseVertex);
             }
-        }
+		}
+		#endregion
 
-        public void DrawPrimitives(PrimitiveType primitiveType, int vertexOffset, int primitiveCount)
+		#region DrawPrimitives
-        {
+		public void DrawPrimitives(PrimitiveType primitiveType, int vertexOffset, int primitiveCount)
-            SharpDX.Direct3D10.EffectPass pass; SharpDX.Direct3D10.EffectTechnique technique; ShaderBytecode passSignature;
+		{
-            SetupEffectForDraw(out pass, out technique, out passSignature);
+			Dx10.EffectTechnique technique = SetupEffectForDraw();
 
-            SetupInputLayout(passSignature);
-
-            // Prepare All the stages
             device.InputAssembler.PrimitiveTopology = FormatConverter.Translate(primitiveType);
             device.Rasterizer.SetViewports(currentViewport);
-
             device.OutputMerger.SetTargets(this.depthStencilView, this.renderView);
 
             for (int i = 0; i < technique.Description.PassCount; ++i)
-            {
+			{
-                pass.Apply();
+				technique.GetPassByIndex(i).Apply();
                 device.Draw(primitiveCount, vertexOffset);
             }
         }
-
+        #endregion
-        #endregion // DrawPrimitives & DrawIndexedPrimitives
 
         #region DrawInstancedPrimitives
-        public void DrawInstancedPrimitives(PrimitiveType primitiveType, int baseVertex, int minVertexIndex, int numVertices, int startIndex, int primitiveCount, int instanceCount)
+        public void DrawInstancedPrimitives(PrimitiveType primitiveType, int baseVertex, int minVertexIndex, int numVertices,
+			int startIndex, int primitiveCount, int instanceCount)
         {
             device.DrawIndexedInstanced(numVertices, instanceCount, startIndex, baseVertex, 0);
         }
-
+        #endregion
-        #endregion // DrawInstancedPrimitives
 
         #region DrawUserIndexedPrimitives<T>
-        public void DrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices, Array indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration, IndexElementSize indexFormat) where T : struct, IVertexType
+        public void DrawUserIndexedPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int numVertices,
+			Array indexData, int indexOffset, int primitiveCount, VertexDeclaration vertexDeclaration,
+			IndexElementSize indexFormat) where T : struct, IVertexType
         {
             int vertexCount = vertexData.Length;
             int indexCount = indexData.Length;
             VertexBuffer_DX10 vb10 = new VertexBuffer_DX10(this.device, vertexDeclaration, vertexCount, BufferUsage.None);
             vb10.SetData<T>(null, vertexData);
 
-            SharpDX.Direct3D10.VertexBufferBinding nativeVertexBufferBindings = new SharpDX.Direct3D10.VertexBufferBinding(vb10.NativeBuffer, vertexDeclaration.VertexStride, 0);
+            Dx10.VertexBufferBinding nativeVertexBufferBindings = new Dx10.VertexBufferBinding(vb10.NativeBuffer,
+				vertexDeclaration.VertexStride, 0);
 
             device.InputAssembler.SetVertexBuffers(0, nativeVertexBufferBindings);
 
             IndexBuffer_DX10 idx10 = new IndexBuffer_DX10(this.device, indexFormat, indexCount, BufferUsage.None);
             if (indexData.GetType()  == typeof(Int16[]))
-            {
                 idx10.SetData<short>(null, (short[])indexData);
-            }
             else
-            {
                 idx10.SetData<int>(null, (int[])indexData);
-            }
 
             DrawIndexedPrimitives(primitiveType, 0, vertexOffset, numVertices, indexOffset, primitiveCount);
         }
-
+        #endregion
-        #endregion // DrawUserIndexedPrimitives<T>
 
         #region DrawUserPrimitives<T>
-        public void DrawUserPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int primitiveCount, VertexDeclaration vertexDeclaration) where T : struct, IVertexType
+        public void DrawUserPrimitives<T>(PrimitiveType primitiveType, T[] vertexData, int vertexOffset, int primitiveCount,
+			VertexDeclaration vertexDeclaration) where T : struct, IVertexType
         {
             int vertexCount = vertexData.Length;
             VertexBuffer_DX10 vb10 = new VertexBuffer_DX10(this.device, vertexDeclaration, vertexCount, BufferUsage.None);
             vb10.SetData<T>(null, vertexData);
 
-            SharpDX.Direct3D10.VertexBufferBinding nativeVertexBufferBindings = new SharpDX.Direct3D10.VertexBufferBinding(vb10.NativeBuffer, vertexDeclaration.VertexStride, 0);
+            Dx10.VertexBufferBinding nativeVertexBufferBindings = new Dx10.VertexBufferBinding(vb10.NativeBuffer,
+				vertexDeclaration.VertexStride, 0);
 
             device.InputAssembler.SetVertexBuffers(0, nativeVertexBufferBindings);
 
-            SharpDX.Direct3D10.EffectPass pass; SharpDX.Direct3D10.EffectTechnique technique; ShaderBytecode passSignature;
+			//TODO: check for currentEffect null and throw exception
-            SetupEffectForDraw(out pass, out technique, out passSignature);
+			// TODO: check for null's and throw exceptions
-
+			// TODO: get the correct pass index!
-            var layout = CreateInputLayout(device, passSignature, vertexDeclaration);
+			var technique = currentEffect.GetCurrentTechnique().NativeTechnique;
+			var pass = technique.GetPassByIndex(0);
+			var layout = CreateInputLayout(device, pass.Description.Signature, vertexDeclaration);
 
             device.InputAssembler.InputLayout = layout;
             // Prepare All the stages
@@ -373,28 +345,25 @@ namespace ANX.RenderSystem.Windows.DX10
                 device.Draw(primitiveCount, vertexOffset);
             }
         }
+        #endregion
 
-        #endregion // DrawUserPrimitives<T>
+		#region SetupEffectForDraw
-
+		private Dx10.EffectTechnique SetupEffectForDraw()
-        private void SetupEffectForDraw(out SharpDX.Direct3D10.EffectPass pass, out SharpDX.Direct3D10.EffectTechnique technique,
-			out ShaderBytecode passSignature)
         {
-            // get the current effect
+			//TODO: check for currentEffect null and throw exception
-            //TODO: check for null and throw exception
-            Effect_DX10 effect = this.currentEffect;
-			
-            // get the input semantic of the current effect / technique that is used
             // TODO: check for null's and throw exceptions
 			// TODO: get the correct pass index!
-			technique = effect.GetCurrentTechnique().NativeTechnique;
+			var technique = currentEffect.GetCurrentTechnique().NativeTechnique;
-            pass = technique.GetPassByIndex(0);
+			var pass = technique.GetPassByIndex(0);
-            passSignature = pass.Description.Signature;
+			SetupInputLayout(pass.Description.Signature);
-        }
 
-        private void SetupInputLayout(ShaderBytecode passSignature)
+			return technique;
+        }
+		#endregion
+
+		#region SetupInputLayout
+		private void SetupInputLayout(ShaderBytecode passSignature)
         {
-            // get the VertexDeclaration from current VertexBuffer to create input layout for the input assembler
-            
             if (currentVertexBuffer == null)
                 throw new ArgumentNullException("passSignature");
 
@@ -403,31 +372,9 @@ namespace ANX.RenderSystem.Windows.DX10
 
             device.InputAssembler.InputLayout = layout;
         }
-
+		#endregion
-        private int CalculateVertexCount(PrimitiveType type, int primitiveCount)
+		
-        {
+		#region SetIndexBuffer
-            if (type == PrimitiveType.TriangleList)
-            {
-                return primitiveCount * 3;
-            }
-            else if (type == PrimitiveType.LineList)
-            {
-                return primitiveCount * 2;
-            }
-            else if (type == PrimitiveType.LineStrip)
-            {
-                return primitiveCount + 1;
-            }
-            else if (type == PrimitiveType.TriangleStrip)
-            {
-                return primitiveCount + 2;
-            }
-            else
-            {
-                throw new NotImplementedException("couldn't calculate vertex count for PrimitiveType '" + type.ToString() + "'");
-            }
-        }
-
         public void SetIndexBuffer(IndexBuffer indexBuffer)
         {
             if (indexBuffer == null)
@@ -448,30 +395,30 @@ namespace ANX.RenderSystem.Windows.DX10
                 throw new Exception("couldn't fetch native DirectX10 IndexBuffer");
             }
         }
+		#endregion
 
 #if XNAEXT
+		#region SetConstantBuffer
         public void SetConstantBuffer(int slot, ANX.Framework.Graphics.ConstantBuffer constantBuffer)
         {
             if (constantBuffer == null)
-            {
                 throw new ArgumentNullException("constantBuffer");
-            }
 
             throw new NotImplementedException();
         }
+		#endregion
 #endif
 
-        public void SetVertexBuffers(VertexBufferBinding[] vertexBuffers)
+		#region SetVertexBuffers
+		public void SetVertexBuffers(VertexBufferBinding[] vertexBuffers)
         {
             if (vertexBuffers == null)
-            {
                 throw new ArgumentNullException("vertexBuffers");
-            }
 
             this.currentVertexBuffer = vertexBuffers[0].VertexBuffer;   //TODO: hmmmmm, not nice :-)
 
-            SharpDX.Direct3D10.VertexBufferBinding[] nativeVertexBufferBindings =
+            Dx10.VertexBufferBinding[] nativeVertexBufferBindings =
-				new SharpDX.Direct3D10.VertexBufferBinding[vertexBuffers.Length];
+				new Dx10.VertexBufferBinding[vertexBuffers.Length];
             for (int i = 0; i < vertexBuffers.Length; i++)
             {
                 ANX.Framework.Graphics.VertexBufferBinding anxVertexBufferBinding = vertexBuffers[i];
@@ -479,7 +426,7 @@ namespace ANX.RenderSystem.Windows.DX10
 
                 if (nativeVertexBuffer != null)
                 {
-                    nativeVertexBufferBindings[i] = new SharpDX.Direct3D10.VertexBufferBinding(nativeVertexBuffer.NativeBuffer,
+                    nativeVertexBufferBindings[i] = new Dx10.VertexBufferBinding(nativeVertexBuffer.NativeBuffer,
 						anxVertexBufferBinding.VertexBuffer.VertexDeclaration.VertexStride, anxVertexBufferBinding.VertexOffset);
                 }
                 else
@@ -489,37 +436,46 @@ namespace ANX.RenderSystem.Windows.DX10
             }
 
             device.InputAssembler.SetVertexBuffers(0, nativeVertexBufferBindings);
-        }
+		}
+		#endregion
 
-        public void SetViewport(Viewport viewport)
+		#region SetViewport
+		public void SetViewport(Viewport viewport)
         {
-            this.currentViewport = new SharpDX.Direct3D10.Viewport(viewport.X, viewport.Y, viewport.Width, viewport.Height,
+            this.currentViewport = new Dx10.Viewport(viewport.X, viewport.Y, viewport.Width, viewport.Height,
 				viewport.MinDepth, viewport.MaxDepth);
         }
+		#endregion
 
-        /// <summary>
+		#region CreateInputLayout
+		/// <summary>
         /// This method creates a InputLayout which is needed by DirectX 10 for rendering primitives.
 		/// The VertexDeclaration of ANX/XNA needs to be mapped to the DirectX 10 types.
         /// </summary>
-        private InputLayout CreateInputLayout(Device device, ShaderBytecode passSignature, VertexDeclaration vertexDeclaration)
+		private Dx10.InputLayout CreateInputLayout(Dx10.Device device, ShaderBytecode passSignature,
+			VertexDeclaration vertexDeclaration)
         {
             VertexElement[] vertexElements = vertexDeclaration.GetVertexElements();
             int elementCount = vertexElements.Length;
-            InputElement[] inputElements = new InputElement[elementCount];
+			var inputElements = new Dx10.InputElement[elementCount];
 
             for (int i = 0; i < elementCount; i++)
                 inputElements[i] = CreateInputElementFromVertexElement(vertexElements[i]);
 
-            return new InputLayout(device, passSignature, inputElements);
+			return new Dx10.InputLayout(device, passSignature, inputElements);
-        }
+		}
+		#endregion
 
-        private InputElement CreateInputElementFromVertexElement(VertexElement vertexElement)
+		#region CreateInputElementFromVertexElement
+		private Dx10.InputElement CreateInputElementFromVertexElement(VertexElement vertexElement)
         {
             string elementName = FormatConverter.Translate(ref vertexElement);
 			Format elementFormat = ConvertVertexElementFormat(vertexElement.VertexElementFormat);
-            return new InputElement(elementName, vertexElement.UsageIndex, elementFormat, vertexElement.Offset, 0);
+			return new Dx10.InputElement(elementName, vertexElement.UsageIndex, elementFormat, vertexElement.Offset, 0);
-        }
+		}
+		#endregion
 
+		#region ConvertVertexElementFormat
 		private Format ConvertVertexElementFormat(VertexElementFormat format)
 		{
 			switch (format)
@@ -543,6 +499,7 @@ namespace ANX.RenderSystem.Windows.DX10
 
 			throw new Exception("Can't map '" + format + "' to DXGI.Format in Dx10 CreateInputElementFromVertexElement.");
 		}
+		#endregion
 
 		#region SetRenderTargets
 		public void SetRenderTargets(params RenderTargetBinding[] renderTargets)
@@ -559,7 +516,7 @@ namespace ANX.RenderSystem.Windows.DX10
                     }
                 }
 
-                device.OutputMerger.SetRenderTargets(1, new RenderTargetView[] { this.renderView }, this.depthStencilView);
+				device.OutputMerger.SetRenderTargets(1, new Dx10.RenderTargetView[] { this.renderView }, this.depthStencilView);
                 device.OutputMerger.SetTargets(this.depthStencilView, this.renderView);
             }
             else
@@ -576,7 +533,7 @@ namespace ANX.RenderSystem.Windows.DX10
                         }
                     }
 
-                    this.renderTargetView = new RenderTargetView[renderTargetCount];
+					this.renderTargetView = new Dx10.RenderTargetView[renderTargetCount];
                 }
 
                 for (int i = 0; i < renderTargetCount; i++)
@@ -591,7 +548,7 @@ namespace ANX.RenderSystem.Windows.DX10
                             renderTargetView[i].Dispose();
                         }
 
-                        renderTargetView[i] = new RenderTargetView(device, ((Texture2D_DX10)nativeRenderTarget).NativeShaderResourceView.Resource);
+						renderTargetView[i] = new Dx10.RenderTargetView(device, ((Texture2D_DX10)nativeRenderTarget).NativeShaderResourceView.Resource);
                     }
                 }
 
@@ -622,7 +579,7 @@ namespace ANX.RenderSystem.Windows.DX10
         }
 		#endregion
 
-		#region GetBackBufferData
+		#region GetBackBufferData (TODO)
 		public void GetBackBufferData<T>(Rectangle? rect, T[] data, int startIndex, int elementCount) where T : struct
         {
             throw new NotImplementedException();
@@ -652,53 +609,22 @@ namespace ANX.RenderSystem.Windows.DX10
                 swapChain.ResizeBuffers(swapChain.Description.BufferCount, presentationParameters.BackBufferWidth,
 					presentationParameters.BackBufferHeight, Format.R8G8B8A8_UNorm, swapChain.Description.Flags);
 
-                backBuffer = SharpDX.Direct3D10.Texture2D.FromSwapChain<SharpDX.Direct3D10.Texture2D>(swapChain, 0);
+                backBuffer = Dx10.Texture2D.FromSwapChain<Dx10.Texture2D>(swapChain, 0);
-                renderView = new RenderTargetView(device, backBuffer);
+				renderView = new Dx10.RenderTargetView(device, backBuffer);
 
-                currentViewport = new SharpDX.Direct3D10.Viewport(0, 0, presentationParameters.BackBufferWidth,
+                currentViewport = new Dx10.Viewport(0, 0, presentationParameters.BackBufferWidth,
 					presentationParameters.BackBufferHeight);
 
                 // create the depth stencil buffer
                 Format depthFormat = FormatConverter.Translate(presentationParameters.DepthStencilFormat);
                 if (depthFormat != Format.Unknown)
-                {
                     CreateDepthStencilBuffer(depthFormat);
-                }
             }
 
-            ResizeRenderWindow(presentationParameters);
+			WindowHelper.ResizeRenderWindow(presentationParameters);
         }
 		#endregion
 
-		#region ResizeRenderWindow
-		private void ResizeRenderWindow(PresentationParameters presentationParameters)
-        {
-            RECT windowRect;
-            RECT clientRect;
-			if (GetWindowRect(presentationParameters.DeviceWindowHandle, out windowRect) &&
-				GetClientRect(presentationParameters.DeviceWindowHandle, out clientRect))
-			{
-				int width = presentationParameters.BackBufferWidth + ((windowRect.Right - windowRect.Left) - clientRect.Right);
-				int height = presentationParameters.BackBufferHeight + ((windowRect.Bottom - windowRect.Top) - clientRect.Bottom);
-
-				SetWindowPos(presentationParameters.DeviceWindowHandle, IntPtr.Zero, windowRect.Left, windowRect.Top, width,
-					height, 0);
-			}
-        }
-		#endregion
-
-        public bool VSync
-        {
-            get
-            {
-                return this.vSyncEnabled;
-            }
-            set
-            {
-                this.vSyncEnabled = value;
-            }
-        }
-
 		#region Dispose
 		public void Dispose()
         {

RenderSystems/ANX.Framework.Windows.DX10/Helpers/FormatConverter.cs

@@ -0,0 +1,360 @@
+using System;
+using ANX.Framework.Graphics;
+using SharpDX.Direct3D;
+using SharpDX.DXGI;
+using Dx10 = SharpDX.Direct3D10;
+
+// This file is part of the ANX.Framework created by the
+// "ANX.Framework developer group" and released under the Ms-PL license.
+// For details see: http://anxframework.codeplex.com/license
+
+namespace ANX.RenderSystem.Windows.DX10.Helpers
+{
+	internal class FormatConverter
+	{
+		#region FormatSize (SurfaceFormat)
+		public static int FormatSize(SurfaceFormat format)
+		{
+			switch (format)
+			{
+				case SurfaceFormat.Vector4:
+					return 16;
+				//case SurfaceFormat.Vector3:
+				//    return 12;
+				case SurfaceFormat.Vector2:
+					return 8;
+				case SurfaceFormat.Single:
+				case SurfaceFormat.Color:
+					//case SurfaceFormat.RGBA1010102:
+					//case SurfaceFormat.RG32:
+					return 4;
+				//case SurfaceFormat.BGR565:
+				//case SurfaceFormat.BGRA5551:
+				//    return 2;
+				case SurfaceFormat.Dxt1:
+				case SurfaceFormat.Dxt3:
+				case SurfaceFormat.Dxt5:
+				case SurfaceFormat.Alpha8:
+					return 1;
+			}
+
+			throw new ArgumentException("Invalid format '" + format + "'.");
+		}
+		#endregion
+
+		#region Translate (SurfaceFormat)
+		public static SharpDX.DXGI.Format Translate(SurfaceFormat surfaceFormat)
+		{
+			switch (surfaceFormat)
+			{
+				case SurfaceFormat.Color:
+					return SharpDX.DXGI.Format.R8G8B8A8_UNorm;
+				case SurfaceFormat.Dxt3:
+					return SharpDX.DXGI.Format.BC2_UNorm;
+				case SurfaceFormat.Dxt5:
+					return SharpDX.DXGI.Format.BC3_UNorm;
+			}
+
+			throw new Exception("can't translate SurfaceFormat: " + surfaceFormat.ToString());
+		}
+		#endregion
+
+		#region Translate (DepthFormat)
+		public static Format Translate(DepthFormat depthFormat)
+		{
+			switch (depthFormat)
+			{
+				case DepthFormat.Depth16:
+					return Format.D16_UNorm;
+				case DepthFormat.Depth24:
+				//TODO: no DirectX10 24Bit depth format???                    
+				case DepthFormat.Depth24Stencil8:
+					return Format.D24_UNorm_S8_UInt;
+				case DepthFormat.None:
+					return Format.Unknown;
+			}
+
+			throw new Exception("can't translate DepthFormat: " + depthFormat.ToString());
+		}
+		#endregion
+
+		#region Translate (Format)
+		public static SurfaceFormat Translate(SharpDX.DXGI.Format format)
+		{
+			switch (format)
+			{
+				case SharpDX.DXGI.Format.R8G8B8A8_UNorm:
+					return SurfaceFormat.Color;
+				case SharpDX.DXGI.Format.BC2_UNorm:
+					return SurfaceFormat.Dxt3;
+				case SharpDX.DXGI.Format.BC3_UNorm:
+					return SurfaceFormat.Dxt5;
+			}
+
+			throw new Exception("can't translate Format: " + format.ToString());
+		}
+		#endregion
+
+		#region Translate (TextureFilter)
+		public static Dx10.Filter Translate(TextureFilter filter)
+		{
+			switch (filter)
+			{
+				case TextureFilter.Anisotropic:
+					return Dx10.Filter.Anisotropic;
+				case TextureFilter.Linear:
+					return Dx10.Filter.MinMagMipLinear;
+				case TextureFilter.LinearMipPoint:
+					return Dx10.Filter.MinMagMipPoint;
+				case TextureFilter.MinLinearMagPointMipLinear:
+					return Dx10.Filter.MinLinearMagPointMipLinear;
+				case TextureFilter.MinLinearMagPointMipPoint:
+					return Dx10.Filter.MinLinearMagMipPoint;
+				case TextureFilter.MinPointMagLinearMipLinear:
+					return Dx10.Filter.MinPointMagMipLinear;
+				case TextureFilter.MinPointMagLinearMipPoint:
+					return Dx10.Filter.MinPointMagLinearMipPoint;
+				case TextureFilter.Point:
+					return Dx10.Filter.MinMagMipPoint;
+				case TextureFilter.PointMipLinear:
+					return Dx10.Filter.MinMagPointMipLinear;
+			}
+
+			throw new NotImplementedException();
+		}
+		#endregion
+
+		#region Translate (TextureAddressMode)
+		public static Dx10.TextureAddressMode Translate(TextureAddressMode addressMode)
+		{
+			switch (addressMode)
+			{
+				case TextureAddressMode.Clamp:
+					return Dx10.TextureAddressMode.Clamp;
+				case TextureAddressMode.Mirror:
+					return Dx10.TextureAddressMode.Mirror;
+				case TextureAddressMode.Wrap:
+					return Dx10.TextureAddressMode.Wrap;
+			}
+
+			return Dx10.TextureAddressMode.Clamp;
+		}
+		#endregion
+
+		#region Translate (PrimitiveType)
+		public static PrimitiveTopology Translate(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 InvalidOperationException("unknown PrimitiveType: " + primitiveType);
+		}
+		#endregion
+
+		#region Translate (IndexElementSize)
+		public static SharpDX.DXGI.Format Translate(IndexElementSize indexElementSize)
+		{
+			switch (indexElementSize)
+			{
+				case IndexElementSize.SixteenBits:
+					return Format.R16_UInt;
+				case IndexElementSize.ThirtyTwoBits:
+					return Format.R32_UInt;
+			}
+
+			throw new InvalidOperationException("unknown IndexElementSize: " + indexElementSize);
+		}
+		#endregion
+
+		#region Translate (VertexElement)
+		public static string Translate(ref VertexElement element)
+		{
+			//TODO: map the other Usages
+			if (element.VertexElementUsage == VertexElementUsage.TextureCoordinate)
+				return "TEXCOORD";
+			else
+				return element.VertexElementUsage.ToString().ToUpperInvariant();
+		}
+		#endregion
+
+		#region Translate (BlendFunction)
+		public static Dx10.BlendOperation Translate(BlendFunction blendFunction)
+		{
+			switch (blendFunction)
+			{
+				case BlendFunction.Add:
+					return Dx10.BlendOperation.Add;
+				case BlendFunction.Max:
+					return Dx10.BlendOperation.Maximum;
+				case BlendFunction.Min:
+					return Dx10.BlendOperation.Minimum;
+				case BlendFunction.ReverseSubtract:
+					return Dx10.BlendOperation.ReverseSubtract;
+				case BlendFunction.Subtract:
+					return Dx10.BlendOperation.Subtract;
+			}
+
+			throw new NotImplementedException();
+		}
+		#endregion
+
+		#region Translate (Blend)
+		public static Dx10.BlendOption Translate(Blend blend)
+		{
+			switch (blend)
+			{
+				case Blend.BlendFactor:
+					return Dx10.BlendOption.BlendFactor;
+				case Blend.DestinationAlpha:
+					return Dx10.BlendOption.DestinationAlpha;
+				case Blend.DestinationColor:
+					return Dx10.BlendOption.DestinationColor;
+				case Blend.InverseBlendFactor:
+					return Dx10.BlendOption.InverseBlendFactor;
+				case Blend.InverseDestinationAlpha:
+					return Dx10.BlendOption.InverseDestinationAlpha;
+				case Blend.InverseDestinationColor:
+					return Dx10.BlendOption.InverseDestinationColor;
+				case Blend.InverseSourceAlpha:
+					return Dx10.BlendOption.InverseSourceAlpha;
+				case Blend.InverseSourceColor:
+					return Dx10.BlendOption.InverseSourceColor;
+				case Blend.One:
+					return Dx10.BlendOption.One;
+				case Blend.SourceAlpha:
+					return Dx10.BlendOption.SourceAlpha;
+				case Blend.SourceAlphaSaturation:
+					return Dx10.BlendOption.SourceAlphaSaturate;
+				case Blend.SourceColor:
+					return Dx10.BlendOption.SourceColor;
+				case Blend.Zero:
+					return Dx10.BlendOption.Zero;
+			}
+
+			throw new NotImplementedException();
+		}
+		#endregion
+
+		#region Translate (ColorWriteChannels)
+		public static Dx10.ColorWriteMaskFlags Translate(ColorWriteChannels colorWriteChannels)
+		{
+			Dx10.ColorWriteMaskFlags mask = 0;
+
+			if ((colorWriteChannels & ColorWriteChannels.All) == ColorWriteChannels.All)
+				mask |= Dx10.ColorWriteMaskFlags.All;
+
+			if ((colorWriteChannels & ColorWriteChannels.Alpha) == ColorWriteChannels.Alpha)
+				mask |= Dx10.ColorWriteMaskFlags.Alpha;
+
+			if ((colorWriteChannels & ColorWriteChannels.Blue) == ColorWriteChannels.Blue)
+				mask |= Dx10.ColorWriteMaskFlags.Blue;
+
+			if ((colorWriteChannels & ColorWriteChannels.Green) == ColorWriteChannels.Green)
+				mask |= Dx10.ColorWriteMaskFlags.Green;
+
+			if ((colorWriteChannels & ColorWriteChannels.Red) == ColorWriteChannels.Red)
+				mask |= Dx10.ColorWriteMaskFlags.Red;
+
+			return mask;
+		}
+		#endregion
+
+		#region Translate (StencilOperation)
+		public static Dx10.StencilOperation Translate(StencilOperation stencilOperation)
+		{
+			switch (stencilOperation)
+			{
+				case StencilOperation.Decrement:
+					return Dx10.StencilOperation.Decrement;
+				case StencilOperation.DecrementSaturation:
+					return Dx10.StencilOperation.DecrementAndClamp;
+				case StencilOperation.Increment:
+					return Dx10.StencilOperation.Increment;
+				case StencilOperation.IncrementSaturation:
+					return Dx10.StencilOperation.IncrementAndClamp;
+				case StencilOperation.Invert:
+					return Dx10.StencilOperation.Invert;
+				case StencilOperation.Keep:
+					return Dx10.StencilOperation.Keep;
+				case StencilOperation.Replace:
+					return Dx10.StencilOperation.Replace;
+				case StencilOperation.Zero:
+					return Dx10.StencilOperation.Zero;
+			}
+
+			throw new NotImplementedException("unknown StencilOperation");
+		}
+		#endregion
+
+		#region Translate (CompareFunction)
+		public static Dx10.Comparison Translate(CompareFunction compareFunction)
+		{
+			switch (compareFunction)
+			{
+				case CompareFunction.Always:
+					return Dx10.Comparison.Always;
+				case CompareFunction.Equal:
+					return Dx10.Comparison.Equal;
+				case CompareFunction.Greater:
+					return Dx10.Comparison.Greater;
+				case CompareFunction.GreaterEqual:
+					return Dx10.Comparison.GreaterEqual;
+				case CompareFunction.Less:
+					return Dx10.Comparison.Less;
+				case CompareFunction.LessEqual:
+					return Dx10.Comparison.LessEqual;
+				case CompareFunction.Never:
+					return Dx10.Comparison.Never;
+				case CompareFunction.NotEqual:
+					return Dx10.Comparison.NotEqual;
+			}
+
+			throw new NotImplementedException("unknown CompareFunction");
+		}
+		#endregion
+
+		#region Translate (CullMode)
+		public static Dx10.CullMode Translate(CullMode cullMode)
+		{
+			if (cullMode == CullMode.CullClockwiseFace)
+				return Dx10.CullMode.Front;
+			else if (cullMode == CullMode.CullCounterClockwiseFace)
+				return Dx10.CullMode.Back;
+			else
+				return Dx10.CullMode.None;
+		}
+		#endregion
+
+		#region Translate (FillMode)
+		public static Dx10.FillMode Translate(FillMode fillMode)
+		{
+			return fillMode == FillMode.WireFrame ? Dx10.FillMode.Wireframe : Dx10.FillMode.Solid;
+		}
+		#endregion
+
+		#region CalculateVertexCount
+		public static int CalculateVertexCount(PrimitiveType type, int primitiveCount)
+		{
+			if (type == PrimitiveType.TriangleList)
+				return primitiveCount * 3;
+			else if (type == PrimitiveType.LineList)
+				return primitiveCount * 2;
+			else if (type == PrimitiveType.LineStrip)
+				return primitiveCount + 1;
+			else if (type == PrimitiveType.TriangleStrip)
+				return primitiveCount + 2;
+
+			throw new NotImplementedException("Couldn't calculate vertex count for PrimitiveType '" + type + "'.");
+		}
+		#endregion
+	}
+}

RenderSystems/ANX.Framework.Windows.DX10/Helpers/IncludeHandler.cs

@@ -1,26 +1,19 @@
-#region Using Statements
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using SharpDX.Direct3D10;
-using SharpDX.D3DCompiler;
 using System.IO;
-using ANX.Framework.NonXNA;
+using SharpDX.D3DCompiler;
-using ANX.Framework.Graphics;
-
-#endregion // Using Statements
 
 // This file is part of the ANX.Framework created by the
 // "ANX.Framework developer group" and released under the Ms-PL license.
 // For details see: http://anxframework.codeplex.com/license
 
-namespace ANX.RenderSystem.Windows.DX10
+namespace ANX.RenderSystem.Windows.DX10.Helpers
 {
     internal class IncludeHandler : Include
     {
         private string directory;
 
+		public IDisposable Shadow { get; set; }
+
         public IncludeHandler(string directory)
         {
             this.directory = directory;
@@ -35,13 +28,7 @@ namespace ANX.RenderSystem.Windows.DX10
         {
             //Console.WriteLine("Including {0} file {1} from directory {2}", type.ToString(), fileName, directory);
 
-            return System.IO.File.OpenRead(System.IO.Path.Combine(directory, fileName));
+            return File.OpenRead(Path.Combine(directory, fileName));
-        }
-
-        public IDisposable Shadow
-        {
-            get;
-            set;
         }
 
         public void Dispose()

RenderSystems/ANX.Framework.Windows.DX10/Helpers/WindowHelper.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Runtime.InteropServices;
+using ANX.Framework.Graphics;
+
+namespace ANX.RenderSystem.Windows.DX10.Helpers
+{
+	internal static class WindowHelper
+	{
+		[StructLayout(LayoutKind.Sequential)]
+		public struct RECT
+		{
+			public int Left;        // x position of upper-left corner 
+			public int Top;         // y position of upper-left corner 
+			public int Right;       // x position of lower-right corner 
+			public int Bottom;      // y position of lower-right corner 
+		}
+
+		[DllImport("user32.dll")]
+		private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int width, int height,
+			uint uFlags);
+
+		[DllImport("user32.dll")]
+		[return: MarshalAs(UnmanagedType.Bool)]
+		private static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
+
+		[DllImport("user32.dll")]
+		[return: MarshalAs(UnmanagedType.Bool)]
+		private static extern bool GetClientRect(IntPtr hWnd, out RECT lpRect);
+
+		#region ResizeRenderWindow
+		public static void ResizeRenderWindow(PresentationParameters presentationParameters)
+		{
+			RECT windowRect;
+			RECT clientRect;
+			if (GetWindowRect(presentationParameters.DeviceWindowHandle, out windowRect) &&
+				GetClientRect(presentationParameters.DeviceWindowHandle, out clientRect))
+			{
+				int width = presentationParameters.BackBufferWidth + ((windowRect.Right - windowRect.Left) - clientRect.Right);
+				int height = presentationParameters.BackBufferHeight + ((windowRect.Bottom - windowRect.Top) - clientRect.Bottom);
+
+				SetWindowPos(presentationParameters.DeviceWindowHandle, IntPtr.Zero, windowRect.Left, windowRect.Top, width,
+					height, 0);
+			}
+		}
+		#endregion
+	}
+}

RenderSystems/ANX.Framework.Windows.DX10/RasterizerState_DX10.cs

@@ -1,172 +1,149 @@
-#region Using Statements
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using SharpDX.Direct3D10;
 using ANX.Framework.Graphics;
 using ANX.Framework.NonXNA;
-
+using ANX.RenderSystem.Windows.DX10.Helpers;
-#endregion // Using Statements
+using Dx10 = SharpDX.Direct3D10;
 
 // This file is part of the ANX.Framework created by the
 // "ANX.Framework developer group" and released under the Ms-PL license.
 // For details see: http://anxframework.codeplex.com/license
 
-using CullMode = ANX.Framework.Graphics.CullMode;
-using FillMode = ANX.Framework.Graphics.FillMode;
-
 namespace ANX.RenderSystem.Windows.DX10
 {
     public class RasterizerState_DX10 : INativeRasterizerState
-    {
+	{
-        #region Private Members
+		private const int intMaxOver16 = int.MaxValue / 16;
-        private RasterizerStateDescription description;
-        private SharpDX.Direct3D10.RasterizerState nativeRasterizerState;
-        private bool nativeRasterizerStateDirty;
-        private bool bound;
 
-        private const int intMaxOver16 = int.MaxValue / 16;
+        #region Private
+        private Dx10.RasterizerStateDescription description;
+        private Dx10.RasterizerState nativeRasterizerState;
+        private bool isDirty;
+        #endregion
 
-        #endregion // Private Members
+		#region Public
+		public bool IsBound { get; private set; }
 
-        public RasterizerState_DX10()
+		public CullMode CullMode
+		{
+			set
+			{
+				Dx10.CullMode cullMode = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.CullMode, ref cullMode);
+			}
+		}
+
+		public float DepthBias
+		{
+			set
+			{
+				// XNA uses a float value in the range of 0f..16f as value
+				// DirectX 10 uses a INT value
+
+				int depthBiasValue = (int)(value * intMaxOver16);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.DepthBias, ref depthBiasValue);
+			}
+		}
+
+		public FillMode FillMode
+		{
+			set
+			{
+				Dx10.FillMode fillMode = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.FillMode, ref fillMode);
+			}
+		}
+
+		public bool MultiSampleAntiAlias
+		{
+			set
+			{
+				if (description.IsMultisampleEnabled != value)
+				{
+					isDirty = true;
+					description.IsMultisampleEnabled = value;
+				}
+			}
+		}
+
+		public bool ScissorTestEnable
+		{
+			set
+			{
+				if (description.IsScissorEnabled != value)
+				{
+					isDirty = true;
+					description.IsScissorEnabled = value;
+				}
+			}
+		}
+
+		public float SlopeScaleDepthBias
+		{
+			set
+			{
+				UpdateValueAndMarkDirtyIfNeeded(ref description.SlopeScaledDepthBias, ref value);
+			}
+		}
+		#endregion
+
+		#region Constructor
+		public RasterizerState_DX10()
         {
-            this.description = new RasterizerStateDescription();
+            description.IsAntialiasedLineEnabled = false;
+            isDirty = true;
+		}
+		#endregion
 
-            this.description.IsAntialiasedLineEnabled = false;
+		#region Apply
-
+		public void Apply(GraphicsDevice graphicsDevice)
-            this.nativeRasterizerStateDirty = true;
-        }
-
-        public void Apply(ANX.Framework.Graphics.GraphicsDevice graphicsDevice)
         {
-            GraphicsDeviceWindowsDX10 gdx10 = graphicsDevice.NativeDevice as GraphicsDeviceWindowsDX10;
+			UpdateNativeRasterizerState(graphicsDevice);
-            Device device = gdx10.NativeDevice;
+            IsBound = true;
+		}
+		#endregion
 
-            UpdateNativeRasterizerState(device);
+		#region Release
-            this.bound = true;
+		public void Release()
-
-            device.Rasterizer.State = this.nativeRasterizerState;
-        }
-
-        public void Release()
         {
-            this.bound = false;
+			IsBound = false;
-        }
+		}
+		#endregion
 
-        public void Dispose()
+		#region Dispose
+		public void Dispose()
         {
-            if (this.nativeRasterizerState != null)
+            if (nativeRasterizerState != null)
             {
-                this.nativeRasterizerState.Dispose();
+                nativeRasterizerState.Dispose();
-                this.nativeRasterizerState = null;
+                nativeRasterizerState = null;
             }
-        }
+		}
+		#endregion
 
-        public bool IsBound
+		#region UpdateNativeRasterizerState
-        {
+		private void UpdateNativeRasterizerState(GraphicsDevice graphicsDevice)
-            get 
+		{
+			Dx10.Device device = (graphicsDevice.NativeDevice as GraphicsDeviceWindowsDX10).NativeDevice;
+
+            if (isDirty == true || nativeRasterizerState == null)
             {
-                return this.bound;    
+				Dispose();
+                nativeRasterizerState = new Dx10.RasterizerState(device, ref description);
+                isDirty = false;
             }
-        }
 
-        public CullMode CullMode
+			device.Rasterizer.State = nativeRasterizerState;
-        {
+		}
-            set 
+		#endregion
-            {
-                SharpDX.Direct3D10.CullMode cullMode = FormatConverter.Translate(value);
 
-                if (description.CullMode != cullMode)
+		#region UpdateValueAndMarkDirtyIfNeeded
-                {
+		private void UpdateValueAndMarkDirtyIfNeeded<T>(ref T currentValue, ref T value)
-                    nativeRasterizerStateDirty = true;
+		{
-                    description.CullMode = cullMode;
+			if (value.Equals(currentValue) == false)
-                }
+			{
-            }
+				isDirty = true;
-        }
+				currentValue = value;
-
+			}
-        public float DepthBias
+		}
-        {
+		#endregion
-            set 
+	}
-            { 
-                // XNA uses a float value in the range of 0f..16f as value
-                // DirectX 10 uses a INT value
-
-                int depthBiasValue = (int)(value * intMaxOver16);
-
-                if (description.DepthBias != depthBiasValue)
-                {
-                    nativeRasterizerStateDirty = true;
-                    description.DepthBias = depthBiasValue;
-                }
-            }
-        }
-
-        public FillMode FillMode
-        {
-            set 
-            {
-                SharpDX.Direct3D10.FillMode fillMode = FormatConverter.Translate(value);
-
-                if (description.FillMode != fillMode)
-                {
-                    nativeRasterizerStateDirty = true;
-                    description.FillMode = fillMode;
-                }
-            }
-        }
-
-        public bool MultiSampleAntiAlias
-        {
-            set 
-            {
-                if (description.IsMultisampleEnabled != value)
-                {
-                    nativeRasterizerStateDirty = true;
-                    description.IsMultisampleEnabled = value;
-                }
-            }
-        }
-
-        public bool ScissorTestEnable
-        {
-            set 
-            {
-                if (description.IsScissorEnabled != value)
-                {
-                    nativeRasterizerStateDirty = true;
-                    description.IsScissorEnabled = value;
-                }
-            }
-        }
-
-        public float SlopeScaleDepthBias
-        {
-            set
-            {
-                if (description.SlopeScaledDepthBias != value)
-                {
-                    nativeRasterizerStateDirty = true;
-                    description.SlopeScaledDepthBias = value;
-                }
-            }
-        }
-
-        private void UpdateNativeRasterizerState(Device device)
-        {
-            if (this.nativeRasterizerStateDirty == true || this.nativeRasterizerState == null)
-            {
-                if (this.nativeRasterizerState != null)
-                {
-                    this.nativeRasterizerState.Dispose();
-                    this.nativeRasterizerState = null;
-                }
-
-                this.nativeRasterizerState = new SharpDX.Direct3D10.RasterizerState(device, ref this.description);
-
-                this.nativeRasterizerStateDirty = false;
-            }
-        }
-    }
 }

RenderSystems/ANX.Framework.Windows.DX10/RenderTarget2D_DX10.cs

@@ -1,13 +1,8 @@
-#region Using Statements
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using ANX.Framework.Graphics;
 using ANX.Framework.NonXNA.RenderSystem;
-using SharpDX.Direct3D10;
+using ANX.RenderSystem.Windows.DX10.Helpers;
-
+using Dx10 = SharpDX.Direct3D10;
-#endregion // Using Statements
 
 // This file is part of the ANX.Framework created by the
 // "ANX.Framework developer group" and released under the Ms-PL license.
@@ -16,25 +11,21 @@ using SharpDX.Direct3D10;
 namespace ANX.RenderSystem.Windows.DX10
 {
     public class RenderTarget2D_DX10 : Texture2D_DX10, INativeRenderTarget2D, INativeTexture2D
-    {
+	{
-        #region Private Members
+		#region Constructor
-
+		public RenderTarget2D_DX10(GraphicsDevice graphics, int width, int height, bool mipMap, SurfaceFormat preferredFormat,
-        #endregion // Private Members
+			DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
-
-        public RenderTarget2D_DX10(GraphicsDevice graphics, int width, int height, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
             : base(graphics)
         {
             if (mipMap)
-            {
                 throw new NotImplementedException("creating RenderTargets with mip map not yet implemented");
-            }
 
             this.surfaceFormat = surfaceFormat;
 
             GraphicsDeviceWindowsDX10 graphicsDX10 = graphicsDevice.NativeDevice as GraphicsDeviceWindowsDX10;
-            SharpDX.Direct3D10.Device device = graphicsDX10.NativeDevice;
+            Dx10.Device device = graphicsDX10.NativeDevice;
 
-            SharpDX.Direct3D10.Texture2DDescription description = new SharpDX.Direct3D10.Texture2DDescription()
+            var description = new Dx10.Texture2DDescription()
             {
                 Width = width,
                 Height = height,
@@ -42,19 +33,19 @@ namespace ANX.RenderSystem.Windows.DX10
                 ArraySize = 1,
                 Format = FormatConverter.Translate(preferredFormat),
                 SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
-                Usage = SharpDX.Direct3D10.ResourceUsage.Default,
+                Usage = Dx10.ResourceUsage.Default,
-                BindFlags = SharpDX.Direct3D10.BindFlags.ShaderResource | SharpDX.Direct3D10.BindFlags.RenderTarget,
+                BindFlags = Dx10.BindFlags.ShaderResource | Dx10.BindFlags.RenderTarget,
-                CpuAccessFlags = SharpDX.Direct3D10.CpuAccessFlags.None,
+                CpuAccessFlags = Dx10.CpuAccessFlags.None,
-                OptionFlags = SharpDX.Direct3D10.ResourceOptionFlags.None,
+                OptionFlags = Dx10.ResourceOptionFlags.None,
             };
-            this.nativeTexture = new SharpDX.Direct3D10.Texture2D(graphicsDX10.NativeDevice, description);
+            nativeTexture = new Dx10.Texture2D(graphicsDX10.NativeDevice, description);
-            this.nativeShaderResourceView = new SharpDX.Direct3D10.ShaderResourceView(graphicsDX10.NativeDevice, this.nativeTexture);
+            nativeShaderResourceView = new Dx10.ShaderResourceView(graphicsDX10.NativeDevice, nativeTexture);
 
             // description of texture formats of DX10: http://msdn.microsoft.com/en-us/library/bb694531(v=VS.85).aspx
             // more helpfull information on DX10 textures: http://msdn.microsoft.com/en-us/library/windows/desktop/bb205131(v=vs.85).aspx
 
-            this.formatSize = FormatConverter.FormatSize(surfaceFormat);
+            formatSize = FormatConverter.FormatSize(surfaceFormat);
-        }
+		}
-
+		#endregion
-    }
+	}
 }

RenderSystems/ANX.Framework.Windows.DX10/SamplerState_DX10.cs

@@ -1,10 +1,7 @@
-#region Using Statements
-using System;
 using ANX.Framework.Graphics;
 using ANX.Framework.NonXNA;
-using SharpDX.Direct3D10;
+using ANX.RenderSystem.Windows.DX10.Helpers;
-
+using Dx10 = SharpDX.Direct3D10;
-#endregion // Using Statements
 
 // This file is part of the ANX.Framework created by the
 // "ANX.Framework developer group" and released under the Ms-PL license.
@@ -14,160 +11,137 @@ namespace ANX.RenderSystem.Windows.DX10
 {
     public class SamplerState_DX10 : INativeSamplerState
     {
-        #region Private Members
+        #region Private
-        private SamplerStateDescription description;
+		private Dx10.SamplerStateDescription description;
-        private SharpDX.Direct3D10.SamplerState nativeSamplerState;
+		private Dx10.SamplerState nativeSamplerState;
-        private bool nativeSamplerStateDirty;
+        private bool isDirty;
-        private bool bound;
+		#endregion
 
-        #endregion // Private Members
+		#region Public
+		public bool IsBound { get; private set; }
 
-        public SamplerState_DX10()
+		public ANX.Framework.Graphics.TextureAddressMode AddressU
+		{
+			set
+			{
+				Dx10.TextureAddressMode mode = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.AddressU, ref mode);
+			}
+		}
+
+		public ANX.Framework.Graphics.TextureAddressMode AddressV
+		{
+			set
+			{
+				Dx10.TextureAddressMode mode = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.AddressV, ref mode);
+			}
+		}
+
+		public ANX.Framework.Graphics.TextureAddressMode AddressW
+		{
+			set
+			{
+				Dx10.TextureAddressMode mode = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.AddressW, ref mode);
+			}
+		}
+
+		public TextureFilter Filter
+		{
+			set
+			{
+				Dx10.Filter filter = FormatConverter.Translate(value);
+				UpdateValueAndMarkDirtyIfNeeded(ref description.Filter, ref filter);
+			}
+		}
+
+		public int MaxAnisotropy
+		{
+			set
+			{
+				UpdateValueAndMarkDirtyIfNeeded(ref description.MaximumAnisotropy, ref value);
+			}
+		}
+
+		public int MaxMipLevel
+		{
+			set
+			{
+				if (description.MaximumLod != value)
+				{
+					description.MaximumLod = value;
+					isDirty = true;
+				}
+			}
+		}
+
+		public float MipMapLevelOfDetailBias
+		{
+			set
+			{
+				UpdateValueAndMarkDirtyIfNeeded(ref description.MipLodBias, ref value);
+			}
+		}
+		#endregion
+
+		#region Constructor
+		public SamplerState_DX10()
         {
-            this.description = new SamplerStateDescription();
+            isDirty = true;
+		}
+		#endregion
 
-            this.nativeSamplerStateDirty = true;
+		#region Apply
-        }
+		public void Apply(GraphicsDevice graphicsDevice, int index)
-
-        public void Apply(GraphicsDevice graphicsDevice, int index)
         {
-            GraphicsDeviceWindowsDX10 gdx10 = graphicsDevice.NativeDevice as GraphicsDeviceWindowsDX10;
+			Dx10.Device device = (graphicsDevice.NativeDevice as GraphicsDeviceWindowsDX10).NativeDevice;
-            Device device = gdx10.NativeDevice;
-
             UpdateNativeSamplerState(device);
-            this.bound = true;
+			IsBound = true;
 
-            device.PixelShader.SetSampler(index, this.nativeSamplerState);
+            device.PixelShader.SetSampler(index, nativeSamplerState);
-        }
+		}
+		#endregion
 
-        public void Release()
+		#region Release
+		public void Release()
         {
-            this.bound = false;
+			IsBound = false;
-        }
+		}
+		#endregion
 
-        public bool IsBound
+		#region Dispose
+		public void Dispose()
         {
-            get 
+            if (nativeSamplerState != null)
-            { 
-                return this.bound; 
-            }
-        }
-
-        public ANX.Framework.Graphics.TextureAddressMode AddressU
-        {
-            set 
             {
-                SharpDX.Direct3D10.TextureAddressMode mode = FormatConverter.Translate(value);
+                nativeSamplerState.Dispose();
-
+                nativeSamplerState = null;
-                if (description.AddressU != mode)
-                {
-                    description.AddressU = mode;
-                    nativeSamplerStateDirty = true;
-                }
             }
         }
+		#endregion
 
-        public ANX.Framework.Graphics.TextureAddressMode AddressV
+		#region UpdateNativeSamplerState
+		private void UpdateNativeSamplerState(Dx10.Device device)
         {
-            set
+            if (isDirty == true || nativeSamplerState == null)
             {
-                SharpDX.Direct3D10.TextureAddressMode mode = FormatConverter.Translate(value);
+				Dispose();
-
+				nativeSamplerState = new Dx10.SamplerState(device, ref description);
-                if (description.AddressV != mode)
+                isDirty = false;
-                {
-                    description.AddressV = mode;
-                    nativeSamplerStateDirty = true;
-                }
             }
-        }
+		}
+		#endregion
 
-        public ANX.Framework.Graphics.TextureAddressMode AddressW
+		#region UpdateValueAndMarkDirtyIfNeeded
-        {
+		private void UpdateValueAndMarkDirtyIfNeeded<T>(ref T currentValue, ref T value)
-            set
+		{
-            {
+			if (value.Equals(currentValue) == false)
-                SharpDX.Direct3D10.TextureAddressMode mode = FormatConverter.Translate(value);
+			{
-
+				isDirty = true;
-                if (description.AddressW != mode)
+				currentValue = value;
-                {
+			}
-                    description.AddressW = mode;
+		}
-                    nativeSamplerStateDirty = true;
+		#endregion
-                }
+	}
-            }
-        }
-
-        public TextureFilter Filter
-        {
-            set 
-            {
-                SharpDX.Direct3D10.Filter filter = FormatConverter.Translate(value);
-
-                if (description.Filter != filter)
-                {
-                    description.Filter = filter;
-                    nativeSamplerStateDirty = true;
-                }
-            }
-        }
-
-        public int MaxAnisotropy
-        {
-            set 
-            {
-                if (description.MaximumAnisotropy != value)
-                {
-                    description.MaximumAnisotropy = value;
-                    nativeSamplerStateDirty = true;
-                }
-            }
-        }
-
-        public int MaxMipLevel
-        {
-            set 
-            {
-                if (description.MaximumLod != value)
-                {
-                    description.MaximumLod = value;
-                    nativeSamplerStateDirty = true;
-                }
-            }
-        }
-
-        public float MipMapLevelOfDetailBias
-        {
-            set 
-            {
-                if (description.MipLodBias != value)
-                {
-                    description.MipLodBias = value;
-                    nativeSamplerStateDirty = true;
-                }
-            }
-        }
-
-        public void Dispose()
-        {
-            if (this.nativeSamplerState != null)
-            {
-                this.nativeSamplerState.Dispose();
-                this.nativeSamplerState = null;
-            }
-        }
-
-        private void UpdateNativeSamplerState(Device device)
-        {
-            if (this.nativeSamplerStateDirty == true || this.nativeSamplerState == null)
-            {
-                if (this.nativeSamplerState != null)
-                {
-                    this.nativeSamplerState.Dispose();
-                    this.nativeSamplerState = null;
-                }
-
-                this.nativeSamplerState = new SharpDX.Direct3D10.SamplerState(device, ref this.description);
-
-                this.nativeSamplerStateDirty = false;
-            }
-        }
-    }
 }

RenderSystems/ANX.Framework.Windows.DX10/Texture2D_DX10.cs

@@ -1,16 +1,11 @@
-#region Using Statements
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using ANX.Framework.Graphics;
-using SharpDX.Direct3D10;
-using ANX.Framework.NonXNA.RenderSystem;
 using System.IO;
 using System.Runtime.InteropServices;
 using ANX.Framework;
-
+using ANX.Framework.Graphics;
-#endregion // Using Statements
+using ANX.Framework.NonXNA.RenderSystem;
+using ANX.RenderSystem.Windows.DX10.Helpers;
+using Dx10 = SharpDX.Direct3D10;
 
 // This file is part of the ANX.Framework created by the
 // "ANX.Framework developer group" and released under the Ms-PL license.
@@ -20,61 +15,16 @@ namespace ANX.RenderSystem.Windows.DX10
 {
 	public class Texture2D_DX10 : INativeTexture2D
 	{
-		#region Private Members
+		#region Private
-		protected internal SharpDX.Direct3D10.Texture2D nativeTexture;
+		protected internal Dx10.Texture2D nativeTexture;
-		protected internal SharpDX.Direct3D10.ShaderResourceView nativeShaderResourceView;
+		protected internal Dx10.ShaderResourceView nativeShaderResourceView;
 		protected internal int formatSize;
 		protected internal SurfaceFormat surfaceFormat;
 		protected internal GraphicsDevice graphicsDevice;
+		#endregion
 
-		#endregion // Private Members
+		#region Public
-
+		internal Dx10.Texture2D NativeTexture
-		internal Texture2D_DX10(GraphicsDevice graphicsDevice)
-		{
-			this.graphicsDevice = graphicsDevice;
-		}
-
-		public Texture2D_DX10(GraphicsDevice graphicsDevice, int width, int height, SurfaceFormat surfaceFormat, int mipCount)
-		{
-			if (mipCount > 1)
-			{
-				throw new Exception("creating textures with mip map not yet implemented");
-			}
-
-			this.graphicsDevice = graphicsDevice;
-			this.surfaceFormat = surfaceFormat;
-
-			GraphicsDeviceWindowsDX10 graphicsDX10 = graphicsDevice.NativeDevice as GraphicsDeviceWindowsDX10;
-			SharpDX.Direct3D10.Device device = graphicsDX10.NativeDevice;
-
-			SharpDX.Direct3D10.Texture2DDescription description = new SharpDX.Direct3D10.Texture2DDescription()
-			{
-				Width = width,
-				Height = height,
-				MipLevels = mipCount,
-				ArraySize = mipCount,
-				Format = FormatConverter.Translate(surfaceFormat),
-				SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
-				Usage = SharpDX.Direct3D10.ResourceUsage.Dynamic,
-				BindFlags = SharpDX.Direct3D10.BindFlags.ShaderResource,
-				CpuAccessFlags = SharpDX.Direct3D10.CpuAccessFlags.Write,
-				OptionFlags = SharpDX.Direct3D10.ResourceOptionFlags.None,
-			};
-			this.nativeTexture = new SharpDX.Direct3D10.Texture2D(graphicsDX10.NativeDevice, description);
-			this.nativeShaderResourceView = new SharpDX.Direct3D10.ShaderResourceView(graphicsDX10.NativeDevice, this.nativeTexture);
-
-			// description of texture formats of DX10: http://msdn.microsoft.com/en-us/library/bb694531(v=VS.85).aspx
-			// more helpfull information on DX10 textures: http://msdn.microsoft.com/en-us/library/windows/desktop/bb205131(v=vs.85).aspx
-
-			this.formatSize = FormatConverter.FormatSize(surfaceFormat);
-		}
-
-		public override int GetHashCode()
-		{
-			return NativeTexture.NativePointer.ToInt32();
-		}
-
-		internal SharpDX.Direct3D10.Texture2D NativeTexture
 		{
 			get
 			{
@@ -85,16 +35,14 @@ namespace ANX.RenderSystem.Windows.DX10
 				if (this.nativeTexture != value)
 				{
 					if (this.nativeTexture != null)
-					{
 						this.nativeTexture.Dispose();
-					}
 
 					this.nativeTexture = value;
 				}
 			}
 		}
 
-		internal SharpDX.Direct3D10.ShaderResourceView NativeShaderResourceView
+		internal Dx10.ShaderResourceView NativeShaderResourceView
 		{
 			get
 			{
@@ -114,6 +62,79 @@ namespace ANX.RenderSystem.Windows.DX10
 			}
 		}
 
+		public int Width
+		{
+			get
+			{
+				return (this.nativeTexture != null) ? this.nativeTexture.Description.Width : 0;
+			}
+		}
+
+		public int Height
+		{
+			get
+			{
+				return (this.nativeTexture != null) ? this.nativeTexture.Description.Height : 0;
+			}
+		}
+
+		public GraphicsDevice GraphicsDevice
+		{
+			get
+			{
+				return this.graphicsDevice;
+			}
+		}
+		#endregion
+
+		#region Constructor
+		internal Texture2D_DX10(GraphicsDevice graphicsDevice)
+		{
+			this.graphicsDevice = graphicsDevice;
+		}
+
+		public Texture2D_DX10(GraphicsDevice graphicsDevice, int width, int height, SurfaceFormat surfaceFormat, int mipCount)
+		{
+			if (mipCount > 1)
+				throw new Exception("creating textures with mip map not yet implemented");
+
+			this.graphicsDevice = graphicsDevice;
+			this.surfaceFormat = surfaceFormat;
+
+			GraphicsDeviceWindowsDX10 graphicsDX10 = graphicsDevice.NativeDevice as GraphicsDeviceWindowsDX10;
+			Dx10.Device device = graphicsDX10.NativeDevice;
+
+			Dx10.Texture2DDescription description = new Dx10.Texture2DDescription()
+			{
+				Width = width,
+				Height = height,
+				MipLevels = mipCount,
+				ArraySize = mipCount,
+				Format = FormatConverter.Translate(surfaceFormat),
+				SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
+				Usage = Dx10.ResourceUsage.Dynamic,
+				BindFlags = Dx10.BindFlags.ShaderResource,
+				CpuAccessFlags = Dx10.CpuAccessFlags.Write,
+				OptionFlags = Dx10.ResourceOptionFlags.None,
+			};
+			this.nativeTexture = new Dx10.Texture2D(graphicsDX10.NativeDevice, description);
+			this.nativeShaderResourceView = new Dx10.ShaderResourceView(graphicsDX10.NativeDevice, this.nativeTexture);
+
+			// description of texture formats of DX10: http://msdn.microsoft.com/en-us/library/bb694531(v=VS.85).aspx
+			// more helpfull information on DX10 textures: http://msdn.microsoft.com/en-us/library/windows/desktop/bb205131(v=vs.85).aspx
+
+			this.formatSize = FormatConverter.FormatSize(surfaceFormat);
+		}
+		#endregion
+
+		#region GetHashCode
+		public override int GetHashCode()
+		{
+			return NativeTexture.NativePointer.ToInt32();
+		}
+		#endregion
+
+		#region SetData
 		public void SetData<T>(GraphicsDevice graphicsDevice, T[] data) where T : struct
 		{
 			SetData<T>(graphicsDevice, 0, data, 0, data.Length);
@@ -124,7 +145,8 @@ namespace ANX.RenderSystem.Windows.DX10
 			SetData<T>(graphicsDevice, 0, data, startIndex, elementCount);
 		}
 
-		public void SetData<T>(GraphicsDevice graphicsDevice, int offsetInBytes, T[] data, int startIndex, int elementCount) where T : struct
+		public void SetData<T>(GraphicsDevice graphicsDevice, int offsetInBytes, T[] data, int startIndex, int elementCount)
+			where T : struct
 		{
 			//TODO: handle offsetInBytes parameter
 			//TODO: handle startIndex parameter
@@ -132,8 +154,8 @@ namespace ANX.RenderSystem.Windows.DX10
 
 			if (this.surfaceFormat == SurfaceFormat.Color)
 			{
-				int subresource = SharpDX.Direct3D10.Texture2D.CalculateSubResourceIndex(0, 0, 1);
+				int subresource = Dx10.Texture2D.CalculateSubResourceIndex(0, 0, 1);
-				SharpDX.DataRectangle rectangle = this.nativeTexture.Map(subresource, SharpDX.Direct3D10.MapMode.WriteDiscard, SharpDX.Direct3D10.MapFlags.None);
+				SharpDX.DataRectangle rectangle = this.nativeTexture.Map(subresource, Dx10.MapMode.WriteDiscard, Dx10.MapFlags.None);
 				int rowPitch = rectangle.Pitch;
 
 				unsafe
@@ -174,8 +196,8 @@ namespace ANX.RenderSystem.Windows.DX10
 					int h = (Height + 3) >> 2;
 					formatSize = (surfaceFormat == SurfaceFormat.Dxt1) ? 8 : 16;
 
-					int subresource = SharpDX.Direct3D10.Texture2D.CalculateSubResourceIndex(0, 0, 1);
+					int subresource = Dx10.Texture2D.CalculateSubResourceIndex(0, 0, 1);
-					SharpDX.DataRectangle rectangle = this.nativeTexture.Map(subresource, SharpDX.Direct3D10.MapMode.WriteDiscard, SharpDX.Direct3D10.MapFlags.None);
+					SharpDX.DataRectangle rectangle = this.nativeTexture.Map(subresource, Dx10.MapMode.WriteDiscard, Dx10.MapFlags.None);
 					SharpDX.DataStream ds = new SharpDX.DataStream(rectangle.DataPointer, Width * Height * 4 * 2, true, true);
 					int pitch = rectangle.Pitch;
 					int col = 0;
@@ -222,40 +244,13 @@ namespace ANX.RenderSystem.Windows.DX10
 			}
 		}
 
-		public int Width
+		public void SetData<T>(int level, Rectangle? rect, T[] data, int startIndex, int elementCount) where T : struct
 		{
-			get
+			throw new NotImplementedException();
-			{
-				if (this.nativeTexture != null)
-				{
-					return this.nativeTexture.Description.Width;
-				}
-
-				return 0;
-			}
-		}
-
-		public int Height
-		{
-			get
-			{
-				if (this.nativeTexture != null)
-				{
-					return this.nativeTexture.Description.Height;
-				}
-
-				return 0;
-			}
-		}
-
-		public GraphicsDevice GraphicsDevice
-		{
-			get
-			{
-				return this.graphicsDevice;
-			}
 		}
+		#endregion
 
+		#region Dispose
 		public void Dispose()
 		{
 			if (this.nativeShaderResourceView != null)
@@ -270,6 +265,7 @@ namespace ANX.RenderSystem.Windows.DX10
 				this.nativeTexture = null;
 			}
 		}
+		#endregion
 
 		#region SaveAsJpeg (TODO)
 		public void SaveAsJpeg(Stream stream, int width, int height)
@@ -285,24 +281,7 @@ namespace ANX.RenderSystem.Windows.DX10
 		}
 		#endregion
 
-		#region INativeTexture2D Member
+		#region GetData (TODO)
-
-
-		public void GetData<T>(int level, Rectangle? rect, T[] data, int startIndex, int elementCount) where T : struct
-		{
-			throw new NotImplementedException();
-		}
-
-		public void SetData<T>(int level, Rectangle? rect, T[] data, int startIndex, int elementCount) where T : struct
-		{
-			throw new NotImplementedException();
-		}
-
-		#endregion
-
-		#region INativeBuffer Member
-
-
 		public void GetData<T>(T[] data) where T : struct
 		{
 			throw new NotImplementedException();
@@ -313,6 +292,10 @@ namespace ANX.RenderSystem.Windows.DX10
 			throw new NotImplementedException();
 		}
 
+		public void GetData<T>(int level, Rectangle? rect, T[] data, int startIndex, int elementCount) where T : struct
+		{
+			throw new NotImplementedException();
+		}
 		#endregion
 	}
 }

RenderSystems/ANX.Framework.Windows.GL3/EffectGL3.cs

@@ -243,16 +243,12 @@ namespace ANX.RenderSystem.Windows.GL3
 		}
 		#endregion
 
-		#region Apply (TODO)
+		#region Apply
 		public void Apply(GraphicsDevice graphicsDevice)
 		{
-			if (GraphicsDeviceWindowsGL3.activeEffect != this)
+			GL.UseProgram(CurrentTechnique.programHandle);
-			{
+			GraphicsDeviceWindowsGL3.activeEffect = this;
-				GL.Enable(EnableCap.Blend);
+			ErrorHelper.Check("UseProgram");
-				GL.UseProgram(CurrentTechnique.programHandle);
-				GraphicsDeviceWindowsGL3.activeEffect = this;
-				ErrorHelper.Check("UseProgram");
-			}
 		}
 		#endregion
 

RenderSystems/ANX.Framework.Windows.GL3/EffectTechniqueGL3.cs

@@ -59,8 +59,7 @@ namespace ANX.RenderSystem.Windows.GL3
 		/// <summary>
 		/// Create a ne effect technique object.
 		/// </summary>
-		internal EffectTechniqueGL3(Effect setParentEffect, string setName,
+		internal EffectTechniqueGL3(Effect setParentEffect, string setName, int setProgramHandle)
-			int setProgramHandle)
 		{
 			parentEffect = setParentEffect;
 			Name = setName;

RenderSystems/ANX.Framework.Windows.GL3/GraphicsDeviceWindowsGL3.cs

@@ -20,17 +20,8 @@ namespace ANX.RenderSystem.Windows.GL3
 		#endregion
 
 		#region Private
-		/// <summary>
-		/// Native graphics context.
-		/// </summary>
 		private GraphicsContext nativeContext;
-
-		/// <summary>
-		/// The OpenTK window info helper class to provide window informations
-		/// to the graphics device.
-		/// </summary>
 		private IWindowInfo nativeWindowInfo;
-
 		private GraphicsMode graphicsMode;
 
 		private int cachedVersionMinor = -1;
@@ -51,9 +42,7 @@ namespace ANX.RenderSystem.Windows.GL3
 		{
 			get
 			{
-				if (Current == null || Current.nativeContext == null)
+				return (Current == null || Current.nativeContext == null) ? false : Current.nativeContext.IsCurrent;
-					return false;
-				return Current.nativeContext.IsCurrent;
 			}
 		}
 		#endregion
@@ -251,19 +240,16 @@ namespace ANX.RenderSystem.Windows.GL3
 		#endregion
 
 		#region DrawIndexedPrimitives
-		public void DrawIndexedPrimitives(PrimitiveType primitiveType,
+		public void DrawIndexedPrimitives(PrimitiveType primitiveType, int baseVertex, int minVertexIndex, int numVertices,
-				int baseVertex, int minVertexIndex, int numVertices, int startIndex,
+			int startIndex, int primitiveCount)
-				int primitiveCount)
 		{
-			// TODO: baseVertex, minVertexIndex, numVertices, startIndex, primitiveCount
+			// TODO: baseVertex, minVertexIndex, numVertices, startIndex
-			DrawElementsType elementsType =
+			DrawElementsType elementsType = boundIndexBuffer.elementSize == IndexElementSize.SixteenBits ?
-				boundIndexBuffer.elementSize == IndexElementSize.SixteenBits ?
 				DrawElementsType.UnsignedShort :
 				DrawElementsType.UnsignedInt;
 
 			int count;
-			BeginMode mode = DatatypesMapping.PrimitiveTypeToBeginMode(primitiveType,
+			BeginMode mode = DatatypesMapping.PrimitiveTypeToBeginMode(primitiveType, primitiveCount, out count);
-				primitiveCount, out count);
 
 			GL.DrawElements(mode, count, elementsType, 0);
 			ErrorHelper.Check("DrawElements");
@@ -348,8 +334,7 @@ namespace ANX.RenderSystem.Windows.GL3
 			boundVertexBuffers = new VertexBufferGL3[vertexBuffers.Length];
 			for (int index = 0; index < vertexBuffers.Length; index++)
 			{
-				var nativeBuffer =
+				var nativeBuffer = (VertexBufferGL3)vertexBuffers[index].VertexBuffer.NativeVertexBuffer;
-					(VertexBufferGL3)vertexBuffers[index].VertexBuffer.NativeVertexBuffer;
 				boundVertexBuffers[index] = nativeBuffer;
 				nativeBuffer.Bind(activeEffect);
 			}
@@ -359,12 +344,8 @@ namespace ANX.RenderSystem.Windows.GL3
 		#region SetIndexBuffer
 		public void SetIndexBuffer(IndexBuffer indexBuffer)
 		{
-			IndexBufferGL3 nativeBuffer =
+			boundIndexBuffer = (IndexBufferGL3)indexBuffer.NativeIndexBuffer;
-				(IndexBufferGL3)indexBuffer.NativeIndexBuffer;
+			GL.BindBuffer(BufferTarget.ElementArrayBuffer, boundIndexBuffer.BufferHandle);
-
-			boundIndexBuffer = nativeBuffer;
-			GL.BindBuffer(BufferTarget.ElementArrayBuffer,
-				nativeBuffer.BufferHandle);
 			ErrorHelper.Check("BindBuffer");
 		}
 		#endregion

RenderSystems/ANX.Framework.Windows.GL3/Helpers/DatatypesMapping.cs

@@ -1,8 +1,8 @@
 using System;
+using ANX.Framework;
 using ANX.Framework.Graphics;
 using OpenTK.Graphics;
 using OpenTK.Graphics.OpenGL;
-using ANX.Framework;
 
 // This file is part of the ANX.Framework created by the
 // "ANX.Framework developer group" and released under the Ms-PL license.
@@ -194,8 +194,7 @@ namespace ANX.RenderSystem.Windows.GL3.Helpers
 		/// </summary>
 		/// <param name="type">XNA PrimitiveType.</param>
 		/// <returns>Translated BeginMode for OpenGL.</returns>
-		public static BeginMode PrimitiveTypeToBeginMode(PrimitiveType type,
+		public static BeginMode PrimitiveTypeToBeginMode(PrimitiveType type, int primitiveCount, out int count)
-			int primitiveCount, out int count)
 		{
 			switch (type)
 			{

RenderSystems/ANX.Framework.Windows.GL3/ShaderByteCode.cs

@@ -158,31 +158,112 @@ namespace ANX.Framework.Windows.GL3
 		#region DualTextureEffectShader
 		internal static byte[] DualTextureEffectByteCode = new byte[]
 		{
-			155, 005, 118, 101, 114, 116, 101, 120, 115, 104, 097, 100, 101, 114, 115,
+			228, 019, 118, 101, 114, 116, 101, 120, 103, 108, 111, 098, 097, 108, 123,
+			117, 110, 105, 102, 111, 114, 109, 032, 118, 101, 099, 052, 032, 068, 105,
+			102, 102, 117, 115, 101, 067, 111, 108, 111, 114, 059, 117, 110, 105, 102,
+			111, 114, 109, 032, 118, 101, 099, 052, 032, 070, 111, 103, 086, 101, 099,
+			116, 111, 114, 059, 117, 110, 105, 102, 111, 114, 109, 032, 109, 097, 116,
+			052, 032, 087, 111, 114, 108, 100, 086, 105, 101, 119, 080, 114, 111, 106,
+			059, 125, 118, 101, 114, 116, 101, 120, 115, 104, 097, 100, 101, 114, 115,
 			123, 115, 104, 097, 100, 101, 114, 032, 034, 086, 083, 068, 117, 097, 108,
-			084, 101, 120, 116, 117, 114, 101, 034, 123, 117, 110, 105, 102, 111, 114,
+			084, 101, 120, 116, 117, 114, 101, 034, 123, 097, 116, 116, 114, 105, 098,
-			109, 032, 109, 097, 116, 052, 032, 087, 111, 114, 108, 100, 086, 105, 101,
+			117, 116, 101, 032, 118, 101, 099, 052, 032, 112, 111, 115, 059, 097, 116,
-			119, 080, 114, 111, 106, 059, 097, 116, 116, 114, 105, 098, 117, 116, 101,
+			116, 114, 105, 098, 117, 116, 101, 032, 118, 101, 099, 050, 032, 116, 101,
-			032, 118, 101, 099, 052, 032, 112, 111, 115, 059, 097, 116, 116, 114, 105,
+			120, 059, 097, 116, 116, 114, 105, 098, 117, 116, 101, 032, 118, 101, 099,
-			098, 117, 116, 101, 032, 118, 101, 099, 050, 032, 116, 101, 120, 059, 097,
+			050, 032, 116, 101, 120, 050, 059, 118, 097, 114, 121, 105, 110, 103, 032,
-			116, 116, 114, 105, 098, 117, 116, 101, 032, 118, 101, 099, 050, 032, 116,
+			118, 101, 099, 052, 032, 100, 105, 102, 102, 117, 115, 101, 059, 118, 097,
-			101, 120, 050, 059, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101, 099,
+			114, 121, 105, 110, 103, 032, 118, 101, 099, 052, 032, 115, 112, 101, 099,
+			117, 108, 097, 114, 059, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101,
+			099, 050, 032, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111,
+			111, 114, 100, 059, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101, 099,
 			050, 032, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111, 111,
-			114, 100, 059, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101, 099, 050,
+			114, 100, 050, 059, 118, 111, 105, 100, 032, 109, 097, 105, 110, 040, 032,
+			041, 123, 103, 108, 095, 080, 111, 115, 105, 116, 105, 111, 110, 061, 087,
+			111, 114, 108, 100, 086, 105, 101, 119, 080, 114, 111, 106, 042, 112, 111,
+			115, 059, 100, 105, 102, 102, 117, 115, 101, 061, 068, 105, 102, 102, 117,
+			115, 101, 067, 111, 108, 111, 114, 059, 115, 112, 101, 099, 117, 108, 097,
+			114, 061, 118, 101, 099, 052, 040, 048, 044, 048, 044, 048, 044, 115, 097,
+			116, 117, 114, 097, 116, 101, 040, 100, 111, 116, 040, 112, 111, 115, 044,
+			070, 111, 103, 086, 101, 099, 116, 111, 114, 041, 041, 041, 059, 100, 105,
+			102, 102, 117, 115, 101, 084, 101, 120, 067, 111, 111, 114, 100, 061, 116,
+			101, 120, 059, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111,
+			111, 114, 100, 050, 061, 116, 101, 120, 050, 059, 125, 125, 115, 104, 097,
+			100, 101, 114, 032, 034, 086, 083, 068, 117, 097, 108, 084, 101, 120, 116,
+			117, 114, 101, 078, 111, 070, 111, 103, 034, 123, 097, 116, 116, 114, 105,
+			098, 117, 116, 101, 032, 118, 101, 099, 052, 032, 112, 111, 115, 059, 097,
+			116, 116, 114, 105, 098, 117, 116, 101, 032, 118, 101, 099, 050, 032, 116,
+			101, 120, 059, 097, 116, 116, 114, 105, 098, 117, 116, 101, 032, 118, 101,
+			099, 050, 032, 116, 101, 120, 050, 059, 118, 097, 114, 121, 105, 110, 103,
+			032, 118, 101, 099, 052, 032, 100, 105, 102, 102, 117, 115, 101, 059, 118,
+			097, 114, 121, 105, 110, 103, 032, 118, 101, 099, 050, 032, 100, 105, 102,
+			102, 117, 115, 101, 084, 101, 120, 067, 111, 111, 114, 100, 059, 118, 097,
+			114, 121, 105, 110, 103, 032, 118, 101, 099, 050, 032, 100, 105, 102, 102,
+			117, 115, 101, 084, 101, 120, 067, 111, 111, 114, 100, 050, 059, 118, 111,
+			105, 100, 032, 109, 097, 105, 110, 040, 032, 041, 123, 103, 108, 095, 080,
+			111, 115, 105, 116, 105, 111, 110, 061, 087, 111, 114, 108, 100, 086, 105,
+			101, 119, 080, 114, 111, 106, 042, 112, 111, 115, 059, 100, 105, 102, 102,
+			117, 115, 101, 061, 068, 105, 102, 102, 117, 115, 101, 067, 111, 108, 111,
+			114, 059, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111, 111,
+			114, 100, 061, 116, 101, 120, 059, 100, 105, 102, 102, 117, 115, 101, 084,
+			101, 120, 067, 111, 111, 114, 100, 050, 061, 116, 101, 120, 050, 059, 125,
+			125, 115, 104, 097, 100, 101, 114, 032, 034, 086, 083, 068, 117, 097, 108,
+			084, 101, 120, 116, 117, 114, 101, 086, 101, 114, 116, 101, 120, 067, 111,
+			108, 111, 114, 034, 123, 097, 116, 116, 114, 105, 098, 117, 116, 101, 032,
+			118, 101, 099, 052, 032, 112, 111, 115, 059, 097, 116, 116, 114, 105, 098,
+			117, 116, 101, 032, 118, 101, 099, 050, 032, 116, 101, 120, 059, 097, 116,
+			116, 114, 105, 098, 117, 116, 101, 032, 118, 101, 099, 050, 032, 116, 101,
+			120, 050, 059, 097, 116, 116, 114, 105, 098, 117, 116, 101, 032, 118, 101,
+			099, 052, 032, 099, 111, 108, 059, 118, 097, 114, 121, 105, 110, 103, 032,
+			118, 101, 099, 052, 032, 100, 105, 102, 102, 117, 115, 101, 059, 118, 097,
+			114, 121, 105, 110, 103, 032, 118, 101, 099, 052, 032, 115, 112, 101, 099,
+			117, 108, 097, 114, 059, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101,
+			099, 050, 032, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111,
+			111, 114, 100, 059, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101, 099,
+			050, 032, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111, 111,
+			114, 100, 050, 059, 118, 111, 105, 100, 032, 109, 097, 105, 110, 040, 032,
+			041, 123, 103, 108, 095, 080, 111, 115, 105, 116, 105, 111, 110, 061, 087,
+			111, 114, 108, 100, 086, 105, 101, 119, 080, 114, 111, 106, 042, 112, 111,
+			115, 059, 100, 105, 102, 102, 117, 115, 101, 061, 068, 105, 102, 102, 117,
+			115, 101, 067, 111, 108, 111, 114, 042, 099, 111, 108, 059, 115, 112, 101,
+			099, 117, 108, 097, 114, 061, 118, 101, 099, 052, 040, 048, 044, 048, 044,
+			048, 044, 115, 097, 116, 117, 114, 097, 116, 101, 040, 100, 111, 116, 040,
+			112, 111, 115, 044, 070, 111, 103, 086, 101, 099, 116, 111, 114, 041, 041,
+			041, 059, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111, 111,
+			114, 100, 061, 116, 101, 120, 059, 100, 105, 102, 102, 117, 115, 101, 084,
+			101, 120, 067, 111, 111, 114, 100, 050, 061, 116, 101, 120, 050, 059, 125,
+			125, 115, 104, 097, 100, 101, 114, 032, 034, 086, 083, 068, 117, 097, 108,
+			084, 101, 120, 116, 117, 114, 101, 086, 101, 114, 116, 101, 120, 067, 111,
+			108, 111, 114, 078, 111, 070, 111, 103, 034, 123, 097, 116, 116, 114, 105,
+			098, 117, 116, 101, 032, 118, 101, 099, 052, 032, 112, 111, 115, 059, 097,
+			116, 116, 114, 105, 098, 117, 116, 101, 032, 118, 101, 099, 050, 032, 116,
+			101, 120, 059, 097, 116, 116, 114, 105, 098, 117, 116, 101, 032, 118, 101,
+			099, 050, 032, 116, 101, 120, 050, 059, 097, 116, 116, 114, 105, 098, 117,
+			116, 101, 032, 118, 101, 099, 052, 032, 099, 111, 108, 059, 118, 097, 114,
+			121, 105, 110, 103, 032, 118, 101, 099, 052, 032, 100, 105, 102, 102, 117,
+			115, 101, 059, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101, 099, 050,
 			032, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111, 111, 114,
-			100, 050, 059, 118, 111, 105, 100, 032, 109, 097, 105, 110, 040, 032, 041,
+			100, 059, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101, 099, 050, 032,
-			123, 103, 108, 095, 080, 111, 115, 105, 116, 105, 111, 110, 061, 087, 111,
+			100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111, 111, 114, 100,
-			114, 108, 100, 086, 105, 101, 119, 080, 114, 111, 106, 042, 112, 111, 115,
+			050, 059, 118, 111, 105, 100, 032, 109, 097, 105, 110, 040, 032, 041, 123,
-			059, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111, 111, 114,
+			103, 108, 095, 080, 111, 115, 105, 116, 105, 111, 110, 061, 087, 111, 114,
-			100, 061, 116, 101, 120, 059, 100, 105, 102, 102, 117, 115, 101, 084, 101,
+			108, 100, 086, 105, 101, 119, 080, 114, 111, 106, 042, 112, 111, 115, 059,
-			120, 067, 111, 111, 114, 100, 050, 061, 116, 101, 120, 050, 059, 125, 125,
+			100, 105, 102, 102, 117, 115, 101, 061, 068, 105, 102, 102, 117, 115, 101,
-			125, 102, 114, 097, 103, 109, 101, 110, 116, 115, 104, 097, 100, 101, 114,
+			067, 111, 108, 111, 114, 042, 099, 111, 108, 059, 100, 105, 102, 102, 117,
-			115, 123, 115, 104, 097, 100, 101, 114, 032, 034, 080, 083, 068, 117, 097,
+			115, 101, 084, 101, 120, 067, 111, 111, 114, 100, 061, 116, 101, 120, 059,
-			108, 084, 101, 120, 116, 117, 114, 101, 034, 123, 117, 110, 105, 102, 111,
+			100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111, 111, 114, 100,
+			050, 061, 116, 101, 120, 050, 059, 125, 125, 125, 102, 114, 097, 103, 109,
+			101, 110, 116, 103, 108, 111, 098, 097, 108, 123, 117, 110, 105, 102, 111,
 			114, 109, 032, 115, 097, 109, 112, 108, 101, 114, 050, 068, 032, 084, 101,
 			120, 116, 117, 114, 101, 059, 117, 110, 105, 102, 111, 114, 109, 032, 115,
 			097, 109, 112, 108, 101, 114, 050, 068, 032, 084, 101, 120, 116, 117, 114,
-			101, 050, 059, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101, 099, 050,
+			101, 050, 059, 117, 110, 105, 102, 111, 114, 109, 032, 118, 101, 099, 051,
+			032, 070, 111, 103, 067, 111, 108, 111, 114, 059, 125, 102, 114, 097, 103,
+			109, 101, 110, 116, 115, 104, 097, 100, 101, 114, 115, 123, 115, 104, 097,
+			100, 101, 114, 032, 034, 080, 083, 068, 117, 097, 108, 084, 101, 120, 116,
+			117, 114, 101, 034, 123, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101,
+			099, 052, 032, 100, 105, 102, 102, 117, 115, 101, 059, 118, 097, 114, 121,
+			105, 110, 103, 032, 118, 101, 099, 052, 032, 115, 112, 101, 099, 117, 108,
+			097, 114, 059, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101, 099, 050,
 			032, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111, 111, 114,
 			100, 059, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101, 099, 050, 032,
 			100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111, 111, 114, 100,
@@ -194,19 +275,63 @@ namespace ANX.Framework.Windows.GL3
 			101, 120, 116, 117, 114, 101, 050, 068, 040, 084, 101, 120, 116, 117, 114,
 			101, 050, 044, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111,
 			111, 114, 100, 050, 041, 059, 099, 111, 108, 111, 114, 046, 114, 103, 098,
-			032, 042, 061, 032, 050, 059, 103, 108, 095, 070, 114, 097, 103, 067, 111,
+			032, 042, 061, 032, 050, 059, 099, 111, 108, 111, 114, 032, 042, 061, 032,
-			108, 111, 114, 061, 099, 111, 108, 111, 114, 059, 125, 125, 125, 116, 101,
+			111, 118, 101, 114, 108, 097, 121, 042, 100, 105, 102, 102, 117, 115, 101,
-			099, 104, 110, 105, 113, 117, 101, 115, 123, 116, 101, 099, 104, 110, 105,
+			059, 099, 111, 108, 111, 114, 046, 114, 103, 098, 061, 108, 101, 114, 112,
-			113, 117, 101, 032, 034, 068, 117, 097, 108, 084, 101, 120, 116, 117, 114,
+			040, 099, 111, 108, 111, 114, 046, 114, 103, 098, 044, 070, 111, 103, 067,
-			101, 069, 102, 102, 101, 099, 116, 034, 123, 118, 101, 114, 116, 101, 120,
+			111, 108, 111, 114, 042, 099, 111, 108, 111, 114, 046, 097, 044, 115, 112,
-			032, 034, 083, 112, 114, 105, 116, 101, 086, 101, 114, 116, 101, 120, 083,
+			101, 099, 117, 108, 097, 114, 046, 119, 041, 059, 103, 108, 095, 070, 114,
-			104, 097, 100, 101, 114, 034, 102, 114, 097, 103, 109, 101, 110, 116, 032,
+			097, 103, 067, 111, 108, 111, 114, 061, 099, 111, 108, 111, 114, 059, 125,
-			034, 083, 112, 114, 105, 116, 101, 070, 114, 097, 103, 109, 101, 110, 116,
+			125, 115, 104, 097, 100, 101, 114, 032, 034, 080, 083, 068, 117, 097, 108,
-			083, 104, 097, 100, 101, 114, 034, 125, 125, 187, 064, 170, 146, 113, 222,
+			084, 101, 120, 116, 117, 114, 101, 078, 111, 070, 111, 103, 034, 123, 118,
-			195, 185, 241, 224, 197, 214, 045, 090, 110, 247, 026, 116, 240, 217, 022,
+			097, 114, 121, 105, 110, 103, 032, 118, 101, 099, 052, 032, 100, 105, 102,
-			092, 081, 220, 169, 002, 136, 173, 102, 023, 033, 241, 036, 012, 008, 239,
+			102, 117, 115, 101, 059, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101,
-			183, 058, 168, 109, 213, 077, 167, 248, 035, 223, 044, 042, 036, 164, 161,
+			099, 050, 032, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111,
-			159, 223, 225, 129, 012, 168, 228, 127, 147, 224, 089, 079, 235
+			111, 114, 100, 059, 118, 097, 114, 121, 105, 110, 103, 032, 118, 101, 099,
+			050, 032, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111, 111,
+			114, 100, 050, 059, 118, 111, 105, 100, 032, 109, 097, 105, 110, 040, 032,
+			041, 123, 118, 101, 099, 052, 032, 099, 111, 108, 111, 114, 061, 116, 101,
+			120, 116, 117, 114, 101, 050, 068, 040, 084, 101, 120, 116, 117, 114, 101,
+			044, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120, 067, 111, 111, 114,
+			100, 041, 059, 118, 101, 099, 052, 032, 111, 118, 101, 114, 108, 097, 121,
+			061, 116, 101, 120, 116, 117, 114, 101, 050, 068, 040, 084, 101, 120, 116,
+			117, 114, 101, 050, 044, 100, 105, 102, 102, 117, 115, 101, 084, 101, 120,
+			067, 111, 111, 114, 100, 050, 041, 059, 099, 111, 108, 111, 114, 046, 114,
+			103, 098, 032, 042, 061, 032, 050, 059, 099, 111, 108, 111, 114, 032, 042,
+			061, 032, 111, 118, 101, 114, 108, 097, 121, 042, 100, 105, 102, 102, 117,
+			115, 101, 059, 103, 108, 095, 070, 114, 097, 103, 067, 111, 108, 111, 114,
+			061, 099, 111, 108, 111, 114, 059, 125, 125, 125, 116, 101, 099, 104, 110,
+			105, 113, 117, 101, 115, 123, 116, 101, 099, 104, 110, 105, 113, 117, 101,
+			032, 034, 068, 117, 097, 108, 084, 101, 120, 116, 117, 114, 101, 069, 102,
+			102, 101, 099, 116, 034, 123, 118, 101, 114, 116, 101, 120, 032, 034, 086,
+			083, 068, 117, 097, 108, 084, 101, 120, 116, 117, 114, 101, 034, 102, 114,
+			097, 103, 109, 101, 110, 116, 032, 034, 080, 083, 068, 117, 097, 108, 084,
+			101, 120, 116, 117, 114, 101, 034, 125, 116, 101, 099, 104, 110, 105, 113,
+			117, 101, 032, 034, 068, 117, 097, 108, 084, 101, 120, 116, 117, 114, 101,
+			069, 102, 102, 101, 099, 116, 078, 111, 070, 111, 103, 034, 123, 118, 101,
+			114, 116, 101, 120, 032, 034, 086, 083, 068, 117, 097, 108, 084, 101, 120,
+			116, 117, 114, 101, 078, 111, 070, 111, 103, 034, 102, 114, 097, 103, 109,
+			101, 110, 116, 032, 034, 080, 083, 068, 117, 097, 108, 084, 101, 120, 116,
+			117, 114, 101, 078, 111, 070, 111, 103, 034, 125, 116, 101, 099, 104, 110,
+			105, 113, 117, 101, 032, 034, 068, 117, 097, 108, 084, 101, 120, 116, 117,
+			114, 101, 069, 102, 102, 101, 099, 116, 086, 101, 114, 116, 101, 120, 067,
+			111, 108, 111, 114, 034, 123, 118, 101, 114, 116, 101, 120, 032, 034, 086,
+			083, 068, 117, 097, 108, 084, 101, 120, 116, 117, 114, 101, 086, 101, 114,
+			116, 101, 120, 067, 111, 108, 111, 114, 034, 102, 114, 097, 103, 109, 101,
+			110, 116, 032, 034, 080, 083, 068, 117, 097, 108, 084, 101, 120, 116, 117,
+			114, 101, 034, 125, 116, 101, 099, 104, 110, 105, 113, 117, 101, 032, 034,
+			068, 117, 097, 108, 084, 101, 120, 116, 117, 114, 101, 069, 102, 102, 101,
+			099, 116, 078, 111, 070, 111, 103, 086, 101, 114, 116, 101, 120, 067, 111,
+			108, 111, 114, 034, 123, 118, 101, 114, 116, 101, 120, 032, 034, 086, 083,
+			068, 117, 097, 108, 084, 101, 120, 116, 117, 114, 101, 086, 101, 114, 116,
+			101, 120, 067, 111, 108, 111, 114, 078, 111, 070, 111, 103, 034, 102, 114,
+			097, 103, 109, 101, 110, 116, 032, 034, 080, 083, 068, 117, 097, 108, 084,
+			101, 120, 116, 117, 114, 101, 078, 111, 070, 111, 103, 034, 125, 125, 175,
+			031, 128, 135, 091, 053, 148, 130, 202, 159, 176, 084, 033, 124, 189, 185,
+			203, 176, 133, 157, 191, 216, 029, 170, 061, 255, 076, 118, 188, 098, 065,
+			207, 215, 039, 153, 215, 233, 181, 035, 132, 019, 152, 136, 212, 164, 051,
+			001, 074, 135, 233, 177, 169, 110, 009, 048, 124, 035, 141, 123, 034, 179,
+			143, 110, 122
 		};
 		#endregion //DualTextureEffectShader
 

RenderSystems/ANX.Framework.Windows.GL3/VertexBufferGL3.cs

@@ -262,24 +262,19 @@ namespace ANX.RenderSystem.Windows.GL3
 		private void MapVertexDeclaration(EffectGL3 effect)
 		{
 			EffectTechniqueGL3 currentTechnique = effect.CurrentTechnique;
-
 			ShaderAttributeGL3[] attributes = currentTechnique.activeAttributes;
 			VertexElement[] elements = vertexDeclaration.GetVertexElements();
 
 			if (elements.Length != attributes.Length)
-			{
+				throw new InvalidOperationException("Mapping the VertexDeclaration onto the glsl attributes failed because " +
-				throw new InvalidOperationException("Mapping the VertexDeclaration " +
+					"we have " + attributes.Length + " Shader Attributes and " + elements.Length + " elements in the vertex " +
-					"onto the glsl attributes failed because we have " +
+					"declaration which doesn't fit!");
-					attributes.Length + " Shader Attributes and " +
-					elements.Length + " elements in the vertex declaration which " +
-					"doesn't fit!");
-			}
 
 			for (int index = 0; index < attributes.Length; index++)
 			{
 				int location = attributes[index].Location;
-				attributes[index].Bind(elements[location].VertexElementUsage,
+				attributes[index].Bind(elements[location].VertexElementUsage, vertexDeclaration.VertexStride,
-					vertexDeclaration.VertexStride, elements[location].Offset);
+					elements[location].Offset);
 			}
 		}
 		#endregion

Samples/DualTextureSample/Program.cs

@@ -18,4 +18,3 @@ namespace DualTextureSample
         }
     }
 }
-

shader/GL3/DualTexture.fx

@@ -2,49 +2,131 @@
 // "ANX.Framework developer group" and released under the Ms-PL license.
 // For details see: http://anxframework.codeplex.com/license
 
-//TODO: dummy implementation / placeholder
+vertexglobal
+{
+	uniform vec4 DiffuseColor;
+	uniform vec4 FogVector;
+    uniform mat4 WorldViewProj;
+}
 
 vertexshaders
 {
   shader "VSDualTexture"
   {
-    uniform mat4 WorldViewProj;
-
     attribute vec4 pos;
     attribute vec2 tex;
     attribute vec2 tex2;
-
+	
+    varying vec4 diffuse;
+    varying vec4 specular;
     varying vec2 diffuseTexCoord;
     varying vec2 diffuseTexCoord2;
     void main( )
     {
       gl_Position = WorldViewProj * pos;
+	  diffuse = DiffuseColor;
+      specular = vec4(0, 0, 0, saturate(dot(pos, FogVector)));
+      diffuseTexCoord = tex;
+      diffuseTexCoord2 = tex2;
+    }
+  }
+  
+  shader "VSDualTextureNoFog"
+  {
+    attribute vec4 pos;
+    attribute vec2 tex;
+    attribute vec2 tex2;
+	
+    varying vec4 diffuse;
+    varying vec2 diffuseTexCoord;
+    varying vec2 diffuseTexCoord2;
+    void main( )
+    {
+      gl_Position = WorldViewProj * pos;
+	  diffuse = DiffuseColor;
+      diffuseTexCoord = tex;
+      diffuseTexCoord2 = tex2;
+    }
+  }
+  
+  shader "VSDualTextureVertexColor"
+  {
+    attribute vec4 pos;
+    attribute vec2 tex;
+    attribute vec2 tex2;
+    attribute vec4 col;
+	
+    varying vec4 diffuse;
+    varying vec4 specular;
+    varying vec2 diffuseTexCoord;
+    varying vec2 diffuseTexCoord2;
+    void main( )
+    {
+      gl_Position = WorldViewProj * pos;
+	  diffuse = DiffuseColor * col;
+      specular = vec4(0, 0, 0, saturate(dot(pos, FogVector)));
+      diffuseTexCoord = tex;
+      diffuseTexCoord2 = tex2;
+    }
+  }
+  
+  shader "VSDualTextureVertexColorNoFog"
+  {
+    attribute vec4 pos;
+    attribute vec2 tex;
+    attribute vec2 tex2;
+    attribute vec4 col;
+	
+    varying vec4 diffuse;
+    varying vec2 diffuseTexCoord;
+    varying vec2 diffuseTexCoord2;
+    void main( )
+    {
+      gl_Position = WorldViewProj * pos;
+	  diffuse = DiffuseColor * col;
       diffuseTexCoord = tex;
       diffuseTexCoord2 = tex2;
     }
   }
 }
 
+fragmentglobal
+{
+  uniform sampler2D Texture;
+  uniform sampler2D Texture2;
+  uniform vec3 FogColor;
+}
+
 fragmentshaders
 {
   shader "PSDualTexture"
   {
-    uniform sampler2D Texture;
+    varying vec4 diffuse;
-    uniform sampler2D Texture2;
+    varying vec4 specular;
-	
     varying vec2 diffuseTexCoord;
     varying vec2 diffuseTexCoord2;
     void main( )
     {
 	  vec4 color = texture2D(Texture, diffuseTexCoord);
 	  vec4 overlay = texture2D(Texture2, diffuseTexCoord2);
-	  
 	  color.rgb *= 2;
-
+	  color *= overlay * diffuse;
-	  // TODO
+	  color.rgb = lerp(color.rgb, FogColor * color.a, specular.w);
-	  //color *= overlay * pin.Diffuse;
+      gl_FragColor = color;
-      //ApplyFog(color, pin.Specular.w);
+    }
-    
+  }
+  
+  shader "PSDualTextureNoFog"
+  {
+    varying vec4 diffuse;
+    varying vec2 diffuseTexCoord;
+    varying vec2 diffuseTexCoord2;
+    void main( )
+    {
+	  vec4 color = texture2D(Texture, diffuseTexCoord);
+	  vec4 overlay = texture2D(Texture2, diffuseTexCoord2);
+	  color.rgb *= 2;
+	  color *= overlay * diffuse;
       gl_FragColor = color;
     }
   }
@@ -54,7 +136,25 @@ techniques
 {
   technique "DualTextureEffect"
   {
-    vertex "SpriteVertexShader"
+    vertex "VSDualTexture"
-    fragment "SpriteFragmentShader"
+    fragment "PSDualTexture"
+  }
+  
+  technique "DualTextureEffectNoFog"
+  {
+    vertex "VSDualTextureNoFog"
+    fragment "PSDualTextureNoFog"
+  }
+  
+  technique "DualTextureEffectVertexColor"
+  {
+    vertex "VSDualTextureVertexColor"
+    fragment "PSDualTexture"
+  }
+  
+  technique "DualTextureEffectNoFogVertexColor"
+  {
+    vertex "VSDualTextureVertexColorNoFog"
+    fragment "PSDualTextureNoFog"
   }
 }