From 7cd60cc3ad4a9041b83fa3e1486a97c4a6e2153e Mon Sep 17 00:00:00 2001
From: Yong Jian Ming <jianming1993@gmail.com>
Date: Sun, 30 Jul 2023 18:05:08 +0800
Subject: [PATCH] Add BasicEffectWithAlphaTest

---
 P3D/Battle/BattleSystemV2/BattleScreen.vb     |   2 +-
 .../Effects/BasicEffectWithAlphaTest.mgfxdx   | Bin 0 -> 84148 bytes
 P3D/Overworld/OverworldScreen.vb              |   2 +-
 P3D/Overworld/OverworldStorage.vb             |   2 +-
 P3D/Overworld/SecretBase/SecretBaseScreen.vb  |   2 +-
 P3D/P3D.vbproj                                |   5 +
 .../Shader/BasicEffectWithAlphaTest.vb        | 358 ++++++++
 P3D/Resources/Shader/EffectHelpers.vb         | 120 +++
 P3D/Screens/Credits/CreditsScreen.vb          |   2 +-
 P3D/Screens/MainMenu/NewNewGameScreen.vb      |   2 +-
 P3D/Screens/MapPreview/MapPreviewScreen.vb    |   2 +-
 P3D/Screens/PC/HallOfFameScreen.vb            |   2 +-
 P3D/Screens/Screen.vb                         |   2 +-
 P3D/World/Lighting.vb                         |  60 +-
 .../Effects/BasicEffectWithAlphaTest.fx       | 832 ++++++++++++++++++
 .../Content/Effects/Common.fxh                |  58 ++
 .../Content/Effects/Lighting.fxh              |  94 ++
 .../Content/Effects/Macros.fxh                |  61 ++
 .../Content/Effects/Structures.fxh            | 166 ++++
 19 files changed, 1762 insertions(+), 10 deletions(-)
 create mode 100644 P3D/Content/Effects/BasicEffectWithAlphaTest.mgfxdx
 create mode 100644 P3D/Resources/Shader/BasicEffectWithAlphaTest.vb
 create mode 100644 P3D/Resources/Shader/EffectHelpers.vb
 create mode 100644 lib/P3D.ContentPipeline/Content/Effects/BasicEffectWithAlphaTest.fx
 create mode 100644 lib/P3D.ContentPipeline/Content/Effects/Common.fxh
 create mode 100644 lib/P3D.ContentPipeline/Content/Effects/Lighting.fxh
 create mode 100644 lib/P3D.ContentPipeline/Content/Effects/Macros.fxh
 create mode 100644 lib/P3D.ContentPipeline/Content/Effects/Structures.fxh

diff --git a/P3D/Battle/BattleSystemV2/BattleScreen.vb b/P3D/Battle/BattleSystemV2/BattleScreen.vb
index c928ae1c5..7d056181b 100644
--- a/P3D/Battle/BattleSystemV2/BattleScreen.vb
+++ b/P3D/Battle/BattleSystemV2/BattleScreen.vb
@@ -153,7 +153,7 @@
             Screen.ImageView.Showing = False
             Screen.ChooseBox.Showing = False
 
-            Effect = New BasicEffect(Core.GraphicsDevice)
+            Effect = New BasicEffectWithAlphaTest(Core.GraphicsDevice)
             Effect.FogEnabled = True
             SkyDome = New SkyDome()
             Camera = New BattleCamera()
diff --git a/P3D/Content/Effects/BasicEffectWithAlphaTest.mgfxdx b/P3D/Content/Effects/BasicEffectWithAlphaTest.mgfxdx
new file mode 100644
index 0000000000000000000000000000000000000000..fee6ce8d19eb33d100cc466e105bf92048dd8016
GIT binary patch
literal 84148
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

literal 0
HcmV?d00001

diff --git a/P3D/Overworld/OverworldScreen.vb b/P3D/Overworld/OverworldScreen.vb
index 018a12405..0236bd413 100644
--- a/P3D/Overworld/OverworldScreen.vb
+++ b/P3D/Overworld/OverworldScreen.vb
@@ -122,7 +122,7 @@ Public Class OverworldScreen
         Me.MouseVisible = False
 
         'Set up 3D environment variables (Effect, Camera, SkyDome and Level):
-        Effect = New BasicEffect(Core.GraphicsDevice)
+        Effect = New BasicEffectWithAlphaTest(Core.GraphicsDevice)
         Effect.FogEnabled = True
 
         Camera = New OverworldCamera()
diff --git a/P3D/Overworld/OverworldStorage.vb b/P3D/Overworld/OverworldStorage.vb
index 48ccd03fc..6a08bf048 100644
--- a/P3D/Overworld/OverworldStorage.vb
+++ b/P3D/Overworld/OverworldStorage.vb
@@ -6,7 +6,7 @@ Public Class OverworldStorage
     Public OverworldScreen As Screen
     Public Level As Level
     Public Camera As Camera
-    Public Effect As BasicEffect
+    Public Effect As BasicEffectWithAlphaTest
     Public SkyDome As SkyDome
 
     ''' <summary>
diff --git a/P3D/Overworld/SecretBase/SecretBaseScreen.vb b/P3D/Overworld/SecretBase/SecretBaseScreen.vb
index 38b228b16..49333db1a 100644
--- a/P3D/Overworld/SecretBase/SecretBaseScreen.vb
+++ b/P3D/Overworld/SecretBase/SecretBaseScreen.vb
@@ -16,7 +16,7 @@
 
         Me.SecretBase = New SecretBase()
 
-        Effect = New BasicEffect(Core.GraphicsDevice)
+        Effect = New BasicEffectWithAlphaTest(Core.GraphicsDevice)
 
         Camera = New SecretBaseCamera()
         Level = New Level()
diff --git a/P3D/P3D.vbproj b/P3D/P3D.vbproj
index 77ab3290b..46b449f16 100644
--- a/P3D/P3D.vbproj
+++ b/P3D/P3D.vbproj
@@ -10997,6 +10997,9 @@
     <Content Include="Content\Data\smashrockitems.dat">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="Content\Effects\BasicEffectWithAlphaTest.mgfxdx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="Content\GUI\GamePad\xboxControllerBack.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
@@ -32572,6 +32575,8 @@
     <Compile Include="Resources\Models\Steps\InsideStepModel.vb" />
     <Compile Include="Resources\Models\Steps\OutsideStepModel.vb" />
     <Compile Include="Resources\Models\Steps\StepModel.vb" />
+    <Compile Include="Resources\Shader\BasicEffectWithAlphaTest.vb" />
+    <Compile Include="Resources\Shader\EffectHelpers.vb" />
     <Compile Include="Resources\Sound\MusicManager.vb" />
     <Compile Include="Resources\Sound\SoundContainer.vb" />
     <Compile Include="Resources\Sound\SongContainer.vb" />
diff --git a/P3D/Resources/Shader/BasicEffectWithAlphaTest.vb b/P3D/Resources/Shader/BasicEffectWithAlphaTest.vb
new file mode 100644
index 000000000..b51585a03
--- /dev/null
+++ b/P3D/Resources/Shader/BasicEffectWithAlphaTest.vb
@@ -0,0 +1,358 @@
+Imports System
+Imports System.IO
+Imports Microsoft.Xna.Framework
+Imports Microsoft.Xna.Framework.Graphics
+
+Public NotInheritable Class BasicEffectWithAlphaTest
+    Inherits Effect
+    Implements IEffectMatrices, IEffectLights, IEffectFog
+
+    Public Property DirectionalLight0 As DirectionalLight Implements IEffectLights.DirectionalLight0
+    Public Property DirectionalLight1 As DirectionalLight Implements IEffectLights.DirectionalLight1
+    Public Property DirectionalLight2 As DirectionalLight Implements IEffectLights.DirectionalLight2
+
+    Public Property World As Matrix Implements IEffectMatrices.World
+        Get
+            Return _world
+        End Get
+        Set(ByVal value As Matrix)
+            _world = value
+            _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.World Or EffectDirtyFlags.WorldViewProj Or EffectDirtyFlags.Fog
+        End Set
+    End Property
+
+    Public Property View As Matrix Implements IEffectMatrices.View
+        Get
+            Return _view
+        End Get
+        Set(ByVal value As Matrix)
+            _view = value
+            _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.WorldViewProj Or EffectDirtyFlags.EyePosition Or EffectDirtyFlags.Fog
+        End Set
+    End Property
+
+    Public Property Projection As Matrix Implements IEffectMatrices.Projection
+        Get
+            Return _projection
+        End Get
+        Set(ByVal value As Matrix)
+            _projection = value
+            _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.WorldViewProj
+        End Set
+    End Property
+
+    Public Property DiffuseColor As Vector3
+        Get
+            Return _diffuseColor
+        End Get
+        Set(ByVal value As Vector3)
+            _diffuseColor = value
+            _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.MaterialColor
+        End Set
+    End Property
+
+    Public Property EmissiveColor As Vector3
+        Get
+            Return _emissiveColor
+        End Get
+        Set(ByVal value As Vector3)
+            _emissiveColor = value
+            _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.MaterialColor
+        End Set
+    End Property
+
+    Public Property SpecularColor As Vector3
+        Get
+            Return _specularColorParam.GetValueVector3()
+        End Get
+        Set(ByVal value As Vector3)
+            _specularColorParam.SetValue(value)
+        End Set
+    End Property
+
+    Public Property SpecularPower As Single
+        Get
+            Return _specularPowerParam.GetValueSingle()
+        End Get
+        Set(ByVal value As Single)
+            _specularPowerParam.SetValue(value)
+        End Set
+    End Property
+
+    Public Property Alpha As Single
+        Get
+            Return _alpha
+        End Get
+        Set(ByVal value As Single)
+            _alpha = value
+            _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.MaterialColor
+        End Set
+    End Property
+
+    Public Property LightingEnabled As Boolean Implements IEffectLights.LightingEnabled
+        Get
+            Return _lightingEnabled
+        End Get
+        Set(ByVal value As Boolean)
+            If _lightingEnabled <> value Then
+                _lightingEnabled = value
+                _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.ShaderIndex Or EffectDirtyFlags.MaterialColor
+            End If
+        End Set
+    End Property
+
+    Public Property PreferPerPixelLighting As Boolean
+        Get
+            Return _preferPerPixelLighting
+        End Get
+        Set(ByVal value As Boolean)
+            If _preferPerPixelLighting <> value Then
+                _preferPerPixelLighting = value
+                _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.ShaderIndex
+            End If
+        End Set
+    End Property
+
+    Public Property AmbientLightColor As Vector3 Implements IEffectLights.AmbientLightColor
+        Get
+            Return _ambientLightColor
+        End Get
+        Set(ByVal value As Vector3)
+            _ambientLightColor = value
+            _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.MaterialColor
+        End Set
+    End Property
+
+    Public Property FogEnabled As Boolean Implements IEffectFog.FogEnabled
+        Get
+            Return _fogEnabled
+        End Get
+        Set(ByVal value As Boolean)
+            If _fogEnabled <> value Then
+                _fogEnabled = value
+                _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.ShaderIndex Or EffectDirtyFlags.FogEnable
+            End If
+        End Set
+    End Property
+
+    Public Property FogStart As Single Implements IEffectFog.FogStart
+        Get
+            Return _fogStart
+        End Get
+        Set(ByVal value As Single)
+            _fogStart = value
+            _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.Fog
+        End Set
+    End Property
+
+    Public Property FogEnd As Single Implements IEffectFog.FogEnd
+        Get
+            Return _fogEnd
+        End Get
+        Set(ByVal value As Single)
+            _fogEnd = value
+            _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.Fog
+        End Set
+    End Property
+
+    Public Property FogColor As Vector3 Implements IEffectFog.FogColor
+        Get
+            Return _fogColorParam.GetValueVector3()
+        End Get
+        Set(ByVal value As Vector3)
+            _fogColorParam.SetValue(value)
+        End Set
+    End Property
+
+    Public Property TextureEnabled As Boolean
+        Get
+            Return _textureEnabled
+        End Get
+        Set(ByVal value As Boolean)
+            If _textureEnabled <> value Then
+                _textureEnabled = value
+                _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.ShaderIndex
+            End If
+        End Set
+    End Property
+
+    Public Property Texture As Texture2D
+        Get
+            Return _textureParam.GetValueTexture2D()
+        End Get
+        Set(ByVal value As Texture2D)
+            _textureParam.SetValue(value)
+        End Set
+    End Property
+
+    Public Property VertexColorEnabled As Boolean
+        Get
+            Return _vertexColorEnabled
+        End Get
+        Set(ByVal value As Boolean)
+            If _vertexColorEnabled <> value Then
+                _vertexColorEnabled = value
+                _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.ShaderIndex
+            End If
+        End Set
+    End Property
+
+    Public Property AlphaCutoff As Single
+        Get
+            Return _alphaTestParam.GetValueSingle()
+        End Get
+        Set(ByVal value As Single)
+            _alphaTestParam.SetValue(value)
+        End Set
+    End Property
+
+    Public Property EnableHardwareInstancing As Boolean
+        Get
+            Return _hwEnabled
+        End Get
+        Set(ByVal value As Boolean)
+            If _hwEnabled <> value Then
+                _hwEnabled = value
+                _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.ShaderIndex
+            End If
+        End Set
+    End Property
+
+    Private _textureParam As EffectParameter
+    Private _diffuseColorParam As EffectParameter
+    Private _emissiveColorParam As EffectParameter
+    Private _specularColorParam As EffectParameter
+    Private _specularPowerParam As EffectParameter
+    Private _eyePositionParam As EffectParameter
+    Private _fogColorParam As EffectParameter
+    Private _fogVectorParam As EffectParameter
+    Private _worldParam As EffectParameter
+    Private _worldInverseTransposeParam As EffectParameter
+    Private _worldViewProjParam As EffectParameter
+    Private _alphaTestParam As EffectParameter
+    Private _lightingEnabled As Boolean
+    Private _preferPerPixelLighting As Boolean
+    Private _oneLight As Boolean
+    Private _fogEnabled As Boolean
+    Private _textureEnabled As Boolean
+    Private _vertexColorEnabled As Boolean
+    Private _world As Matrix = Matrix.Identity
+    Private _view As Matrix = Matrix.Identity
+    Private _projection As Matrix = Matrix.Identity
+    Private _worldView As Matrix
+    Private _diffuseColor As Vector3 = Vector3.One
+    Private _emissiveColor As Vector3 = Vector3.Zero
+    Private _ambientLightColor As Vector3 = Vector3.Zero
+    Private _alpha As Single = 1
+    Private _fogStart As Single
+    Private _fogEnd As Single = 1
+    Private _hwEnabled As Boolean
+    Private _dirtyFlags As EffectDirtyFlags = EffectDirtyFlags.All
+
+    Public Sub New(ByVal device As GraphicsDevice)
+        MyBase.New(device, File.ReadAllBytes(Path.Combine(Path.GetDirectoryName(AppContext.BaseDirectory), "Content", "Effects", "BasicEffectWithAlphaTest.mgfxdx")))
+        CacheEffectParameters(Nothing)
+        DirectionalLight0.Enabled = True
+        SpecularColor = Vector3.One
+        SpecularPower = 16
+        AlphaCutoff = 0
+    End Sub
+
+    Private Sub New(ByVal cloneSource As BasicEffectWithAlphaTest)
+        MyBase.New(cloneSource)
+        CacheEffectParameters(cloneSource)
+        _lightingEnabled = cloneSource.lightingEnabled
+        _preferPerPixelLighting = cloneSource.preferPerPixelLighting
+        _fogEnabled = cloneSource.fogEnabled
+        _textureEnabled = cloneSource.textureEnabled
+        _vertexColorEnabled = cloneSource.vertexColorEnabled
+        _world = cloneSource.world
+        _view = cloneSource.view
+        _projection = cloneSource.projection
+        _diffuseColor = cloneSource.diffuseColor
+        _emissiveColor = cloneSource.emissiveColor
+        _ambientLightColor = cloneSource.ambientLightColor
+        _alpha = cloneSource.alpha
+        _fogStart = cloneSource.fogStart
+        _fogEnd = cloneSource.fogEnd
+    End Sub
+
+    Public Overrides Function Clone() As Effect
+        Return New BasicEffectWithAlphaTest(Me)
+    End Function
+
+    Public Sub EnableDefaultLighting() Implements IEffectLights.EnableDefaultLighting
+        LightingEnabled = True
+        AmbientLightColor = EffectHelpers.EnableDefaultLighting(DirectionalLight0, DirectionalLight1, DirectionalLight2)
+    End Sub
+
+    Protected Overrides Sub OnApply()
+        _dirtyFlags = EffectHelpers.SetWorldViewProjAndFog(_dirtyFlags, _world, _view, _projection, _worldView, _fogEnabled, _fogStart, _fogEnd, _worldViewProjParam, _fogVectorParam)
+
+        If (_dirtyFlags And EffectDirtyFlags.MaterialColor) <> 0 Then
+            EffectHelpers.SetMaterialColor(_lightingEnabled, _alpha, _diffuseColor, _emissiveColor, _ambientLightColor, _diffuseColorParam, _emissiveColorParam)
+            _dirtyFlags = _dirtyFlags And Not EffectDirtyFlags.MaterialColor
+        End If
+
+        If _lightingEnabled Then
+            _dirtyFlags = EffectHelpers.SetLightingMatrices(_dirtyFlags, _world, _view, _worldParam, _worldInverseTransposeParam, _eyePositionParam)
+            Dim newOneLight = Not DirectionalLight1.Enabled AndAlso Not DirectionalLight2.Enabled
+
+            If _oneLight <> newOneLight Then
+                _oneLight = newOneLight
+                _dirtyFlags = _dirtyFlags Or EffectDirtyFlags.ShaderIndex
+            End If
+        End If
+
+        If (_dirtyFlags And EffectDirtyFlags.ShaderIndex) <> 0 Then
+            Dim shaderIndex = 0
+
+            If Not _fogEnabled Then
+                shaderIndex += 1
+            End If
+
+            If _vertexColorEnabled Then
+                shaderIndex += 2
+            End If
+
+            If _textureEnabled Then
+                shaderIndex += 4
+            End If
+
+            If _lightingEnabled Then
+                If _preferPerPixelLighting Then
+                    shaderIndex += 24
+                ElseIf _oneLight Then
+                    shaderIndex += 16
+                Else
+                    shaderIndex += 8
+                End If
+            End If
+
+            If _hwEnabled Then
+                shaderIndex += 32
+            End If
+
+            _dirtyFlags = _dirtyFlags And Not EffectDirtyFlags.ShaderIndex
+            CurrentTechnique = Techniques(shaderIndex)
+        End If
+    End Sub
+
+    Private Sub CacheEffectParameters(ByVal cloneSource As BasicEffectWithAlphaTest)
+        _textureParam = Parameters("Texture")
+        _diffuseColorParam = Parameters("DiffuseColor")
+        _emissiveColorParam = Parameters("EmissiveColor")
+        _specularColorParam = Parameters("SpecularColor")
+        _specularPowerParam = Parameters("SpecularPower")
+        _eyePositionParam = Parameters("EyePosition")
+        _fogColorParam = Parameters("FogColor")
+        _fogVectorParam = Parameters("FogVector")
+        _worldParam = Parameters("World")
+        _worldInverseTransposeParam = Parameters("WorldInverseTranspose")
+        _worldViewProjParam = Parameters("WorldViewProj")
+        _alphaTestParam = Parameters("AlphaTest")
+        DirectionalLight0 = New DirectionalLight(Parameters("DirLight0Direction"), Parameters("DirLight0DiffuseColor"), Parameters("DirLight0SpecularColor"), cloneSource?.DirectionalLight0)
+        DirectionalLight1 = New DirectionalLight(Parameters("DirLight1Direction"), Parameters("DirLight1DiffuseColor"), Parameters("DirLight1SpecularColor"), cloneSource?.DirectionalLight1)
+        DirectionalLight2 = New DirectionalLight(Parameters("DirLight2Direction"), Parameters("DirLight2DiffuseColor"), Parameters("DirLight2SpecularColor"), cloneSource?.DirectionalLight2)
+    End Sub
+End Class
diff --git a/P3D/Resources/Shader/EffectHelpers.vb b/P3D/Resources/Shader/EffectHelpers.vb
new file mode 100644
index 000000000..7c3c59653
--- /dev/null
+++ b/P3D/Resources/Shader/EffectHelpers.vb
@@ -0,0 +1,120 @@
+Imports System
+Imports Microsoft.Xna.Framework
+Imports Microsoft.Xna.Framework.Graphics
+
+<Flags>
+Public Enum EffectDirtyFlags
+    WorldViewProj = 1
+    World = 2
+    EyePosition = 4
+    MaterialColor = 8
+    Fog = 16
+    FogEnable = 32
+    AlphaTest = 64
+    ShaderIndex = 128
+    All = -1
+End Enum
+
+Public Module EffectHelpers
+    Public Function EnableDefaultLighting(ByVal light0 As DirectionalLight, ByVal light1 As DirectionalLight, ByVal light2 As DirectionalLight) As Vector3
+        light0.Direction = New Vector3(-0.5265408F, -0.5735765F, -0.6275069F)
+        light0.DiffuseColor = New Vector3(1, 0.9607844F, 0.8078432F)
+        light0.SpecularColor = New Vector3(1, 0.9607844F, 0.8078432F)
+        light0.Enabled = True
+        
+        light1.Direction = New Vector3(0.7198464F, 0.3420201F, 0.6040227F)
+        light1.DiffuseColor = New Vector3(0.9647059F, 0.7607844F, 0.4078432F)
+        light1.SpecularColor = Vector3.Zero
+        light1.Enabled = True
+        
+        light2.Direction = New Vector3(0.4545195F, -0.7660444F, 0.4545195F)
+        light2.DiffuseColor = New Vector3(0.3231373F, 0.3607844F, 0.3937255F)
+        light2.SpecularColor = New Vector3(0.3231373F, 0.3607844F, 0.3937255F)
+        light2.Enabled = True
+        
+        Return New Vector3(0.05333332F, 0.09882354F, 0.1819608F)
+    End Function
+
+    Public Function SetWorldViewProjAndFog(ByVal dirtyFlags As EffectDirtyFlags, ByRef world As Matrix, ByRef view As Matrix, ByRef projection As Matrix, ByRef worldView As Matrix, ByVal fogEnabled As Boolean, ByVal fogStart As Single, ByVal fogEnd As Single, ByVal worldViewProjParam As EffectParameter, ByVal fogVectorParam As EffectParameter) As EffectDirtyFlags
+        If (dirtyFlags And EffectDirtyFlags.WorldViewProj) <> 0 Then
+            Dim worldViewProj As Matrix = Nothing
+            Matrix.Multiply(world, view, worldView)
+            Matrix.Multiply(worldView, projection, worldViewProj)
+            worldViewProjParam.SetValue(worldViewProj)
+            dirtyFlags = dirtyFlags And Not EffectDirtyFlags.WorldViewProj
+        End If
+
+        If fogEnabled Then
+            If (dirtyFlags And (EffectDirtyFlags.Fog Or EffectDirtyFlags.FogEnable)) <> 0 Then
+                SetFogVector(worldView, fogStart, fogEnd, fogVectorParam)
+                dirtyFlags = dirtyFlags And Not (EffectDirtyFlags.Fog Or EffectDirtyFlags.FogEnable)
+            End If
+        Else
+            If (dirtyFlags And EffectDirtyFlags.FogEnable) <> 0 Then
+                fogVectorParam.SetValue(Vector4.Zero)
+                dirtyFlags = dirtyFlags And Not EffectDirtyFlags.FogEnable
+            End If
+        End If
+
+        Return dirtyFlags
+    End Function
+
+    Public Function SetLightingMatrices(ByVal dirtyFlags As EffectDirtyFlags, ByRef world As Matrix, ByRef view As Matrix, ByVal worldParam As EffectParameter, ByVal worldInverseTransposeParam As EffectParameter, ByVal eyePositionParam As EffectParameter) As EffectDirtyFlags
+        If (dirtyFlags And EffectDirtyFlags.World) <> 0 Then
+            Dim worldTranspose As Matrix = Nothing, worldInverseTranspose As Matrix = Nothing
+            Matrix.Invert(world, worldTranspose)
+            Matrix.Transpose(worldTranspose, worldInverseTranspose)
+            worldParam.SetValue(world)
+            worldInverseTransposeParam.SetValue(worldInverseTranspose)
+            dirtyFlags = dirtyFlags And Not EffectDirtyFlags.World
+        End If
+        
+        If (dirtyFlags And EffectDirtyFlags.EyePosition) <> 0 Then
+            Dim viewInverse As Matrix = Nothing
+            Matrix.Invert(view, viewInverse)
+            eyePositionParam.SetValue(viewInverse.Translation)
+            dirtyFlags = dirtyFlags And Not EffectDirtyFlags.EyePosition
+        End If
+
+        Return dirtyFlags
+    End Function
+
+    Public Sub SetMaterialColor(ByVal lightingEnabled As Boolean, ByVal alpha As Single, ByRef diffuseColor As Vector3, ByRef emissiveColor As Vector3, ByRef ambientLightColor As Vector3, ByVal diffuseColorParam As EffectParameter, ByVal emissiveColorParam As EffectParameter)
+        If lightingEnabled Then
+            Dim diffuse = New Vector4()
+            Dim emissive = New Vector3()
+            diffuse.X = diffuseColor.X * alpha
+            diffuse.Y = diffuseColor.Y * alpha
+            diffuse.Z = diffuseColor.Z * alpha
+            diffuse.W = alpha
+            emissive.X = (emissiveColor.X + ambientLightColor.X * diffuseColor.X) * alpha
+            emissive.Y = (emissiveColor.Y + ambientLightColor.Y * diffuseColor.Y) * alpha
+            emissive.Z = (emissiveColor.Z + ambientLightColor.Z * diffuseColor.Z) * alpha
+            diffuseColorParam.SetValue(diffuse)
+            emissiveColorParam.SetValue(emissive)
+        Else
+            Dim diffuse = New Vector4 With {
+                .X = (diffuseColor.X + emissiveColor.X) * alpha,
+                .Y = (diffuseColor.Y + emissiveColor.Y) * alpha,
+                .Z = (diffuseColor.Z + emissiveColor.Z) * alpha,
+                .W = alpha
+            }
+            diffuseColorParam.SetValue(diffuse)
+        End If
+    End Sub
+
+    Private Sub SetFogVector(ByRef worldView As Matrix, ByVal fogStart As Single, ByVal fogEnd As Single, ByVal fogVectorParam As EffectParameter)
+        If fogStart = fogEnd Then
+            fogVectorParam.SetValue(New Vector4(0, 0, 0, 1))
+        Else
+            Dim scale = 1F / (fogStart - fogEnd)
+            Dim fogVector = New Vector4 With {
+                .X = worldView.M13 * scale,
+                .Y = worldView.M23 * scale,
+                .Z = worldView.M33 * scale,
+                .W = (worldView.M43 + fogStart) * scale
+            }
+            fogVectorParam.SetValue(fogVector)
+        End If
+    End Sub
+End Module
diff --git a/P3D/Screens/Credits/CreditsScreen.vb b/P3D/Screens/Credits/CreditsScreen.vb
index 69a007d44..623cb2c09 100644
--- a/P3D/Screens/Credits/CreditsScreen.vb
+++ b/P3D/Screens/Credits/CreditsScreen.vb
@@ -34,7 +34,7 @@ Public Class CreditsScreen
         Screen.ImageView.Showing = False
         Screen.ChooseBox.Showing = False
 
-        Effect = New BasicEffect(Core.GraphicsDevice)
+        Effect = New BasicEffectWithAlphaTest(Core.GraphicsDevice)
         Effect.FogEnabled = True
         SkyDome = New SkyDome()
         Camera = New CreditsCamera()
diff --git a/P3D/Screens/MainMenu/NewNewGameScreen.vb b/P3D/Screens/MainMenu/NewNewGameScreen.vb
index 5893bcc81..efad81567 100644
--- a/P3D/Screens/MainMenu/NewNewGameScreen.vb
+++ b/P3D/Screens/MainMenu/NewNewGameScreen.vb
@@ -32,7 +32,7 @@
             PokemonForms.Initialize()
 
             'Set up 3D environment variables (Effect, Camera, SkyDome and Level):
-            Effect = New BasicEffect(GraphicsDevice)
+            Effect = New BasicEffectWithAlphaTest(GraphicsDevice)
             Effect.FogEnabled = True
 
             'Reset Construct:
diff --git a/P3D/Screens/MapPreview/MapPreviewScreen.vb b/P3D/Screens/MapPreview/MapPreviewScreen.vb
index 67cc59818..be0055c0f 100644
--- a/P3D/Screens/MapPreview/MapPreviewScreen.vb
+++ b/P3D/Screens/MapPreview/MapPreviewScreen.vb
@@ -26,7 +26,7 @@
         Me.CanMuteAudio = False
         Me.CanTakeScreenshot = True
 
-        Effect = New BasicEffect(Core.GraphicsDevice)
+        Effect = New BasicEffectWithAlphaTest(Core.GraphicsDevice)
         Effect.FogEnabled = True
 
         Camera = New MapPreviewCamera()
diff --git a/P3D/Screens/PC/HallOfFameScreen.vb b/P3D/Screens/PC/HallOfFameScreen.vb
index 9b045fe10..c2bf0f896 100644
--- a/P3D/Screens/PC/HallOfFameScreen.vb
+++ b/P3D/Screens/PC/HallOfFameScreen.vb
@@ -137,7 +137,7 @@
             Screen.ImageView.Showing = False
             Screen.ChooseBox.Showing = False
 
-            Effect = New BasicEffect(Core.GraphicsDevice)
+            Effect = New BasicEffectWithAlphaTest(Core.GraphicsDevice)
             Effect.FogEnabled = True
             SkyDome = New SkyDome()
             Camera = New BattleSystem.BattleCamera()
diff --git a/P3D/Screens/Screen.vb b/P3D/Screens/Screen.vb
index 764fca5fe..994c0bd4e 100644
--- a/P3D/Screens/Screen.vb
+++ b/P3D/Screens/Screen.vb
@@ -126,7 +126,7 @@ Public MustInherit Class Screen
     ''' <summary>
     ''' A global BasicEffect instance, that carries over screen instances.
     ''' </summary>
-    Public Shared Property Effect() As BasicEffect
+    Public Shared Property Effect() As BasicEffectWithAlphaTest
 
     ''' <summary>
     ''' A global SkyDome instance, that carries over screen instances.
diff --git a/P3D/World/Lighting.vb b/P3D/World/Lighting.vb
index f6796de16..cc4379917 100644
--- a/P3D/World/Lighting.vb
+++ b/P3D/World/Lighting.vb
@@ -87,7 +87,65 @@ Public Class Lighting
     ''' <param name="refEffect">A reference to the BasicEffect that should receive the lighting update.</param>
     ''' <param name="ForceLighting">Checks, if the lighting update on the effect should be forced.</param>
     Public Shared Sub UpdateLighting(ByRef refEffect As BasicEffect, Optional ByVal ForceLighting As Boolean = False)
-        If Core.GameOptions.LightingEnabled = True Or ForceLighting = True Then ' Only update the lighting if either the currently loaded level instance allows this, or it's getting forced.
+        If Core.GameOptions.LightingEnabled = True OrElse ForceLighting = True Then ' Only update the lighting if either the currently loaded level instance allows this, or it's getting forced.
+            ' Set default parameters:
+            refEffect.LightingEnabled = True ' Enable lighting (gets disabled later, if not used)
+            refEffect.PreferPerPixelLighting = True ' Yes. Please.
+            refEffect.SpecularPower = 2000.0F
+
+            ' LightType results:
+            ' 0 = Night
+            ' 1 = Morning
+            ' 2 = Day
+            ' 3 = Evening
+            ' Anything higher than 3 = No Lighting
+
+            Select Case GetLightingType()
+
+                Case 0 ' Night
+                    refEffect.AmbientLightColor = GetEnvironmentColor(1)
+
+                    refEffect.DirectionalLight0.DiffuseColor = GetEnvironmentColor(0)
+                    refEffect.DirectionalLight0.Direction = Vector3.Normalize(New Vector3(1.0F, 1.0F, -1.0F))
+                    refEffect.DirectionalLight0.SpecularColor = New Vector3(0.0F)
+                    refEffect.DirectionalLight0.Enabled = True
+                Case 1 ' Morning
+                    refEffect.AmbientLightColor = GetEnvironmentColor(1)
+
+                    refEffect.DirectionalLight0.DiffuseColor = GetEnvironmentColor(0)
+                    refEffect.DirectionalLight0.Direction = Vector3.Normalize(New Vector3(-1.0F, 0.0F, 1.0F))
+                    refEffect.DirectionalLight0.SpecularColor = New Vector3(0.0F)
+                    refEffect.DirectionalLight0.Enabled = True
+                Case 2 ' Day
+                    refEffect.AmbientLightColor = GetEnvironmentColor(1)
+
+                    refEffect.DirectionalLight0.DiffuseColor = GetEnvironmentColor(0)
+                    refEffect.DirectionalLight0.Direction = Vector3.Normalize(New Vector3(-1.0F, 0.0F, 1.0F))
+                    refEffect.DirectionalLight0.SpecularColor = New Vector3(0.0F)
+                    refEffect.DirectionalLight0.Enabled = True
+                Case 3 ' Evening
+                    refEffect.AmbientLightColor = GetEnvironmentColor(1)
+
+                    refEffect.DirectionalLight0.DiffuseColor = GetEnvironmentColor(0)
+                    refEffect.DirectionalLight0.Direction = Vector3.Normalize(New Vector3(1.0F, 1.0F, -1.0F))
+                    refEffect.DirectionalLight0.SpecularColor = New Vector3(0.0F)
+                    refEffect.DirectionalLight0.Enabled = True
+                Case Else  'Disable lighting on the effect
+                    refEffect.LightingEnabled = False
+            End Select
+        Else
+            ' Disable lighting if the effect isn't supposed to have light.
+            refEffect.LightingEnabled = False
+        End If
+    End Sub
+    
+    ''' <summary>
+    ''' Updates the lighting values of a BasicEffect instance.
+    ''' </summary>
+    ''' <param name="refEffect">A reference to the BasicEffect that should receive the lighting update.</param>
+    ''' <param name="ForceLighting">Checks, if the lighting update on the effect should be forced.</param>
+    Public Shared Sub UpdateLighting(ByRef refEffect As BasicEffectWithAlphaTest, Optional ByVal ForceLighting As Boolean = False)
+        If Core.GameOptions.LightingEnabled = True OrElse ForceLighting = True Then ' Only update the lighting if either the currently loaded level instance allows this, or it's getting forced.
             ' Set default parameters:
             refEffect.LightingEnabled = True ' Enable lighting (gets disabled later, if not used)
             refEffect.PreferPerPixelLighting = True ' Yes. Please.
diff --git a/lib/P3D.ContentPipeline/Content/Effects/BasicEffectWithAlphaTest.fx b/lib/P3D.ContentPipeline/Content/Effects/BasicEffectWithAlphaTest.fx
new file mode 100644
index 000000000..9fd90d74e
--- /dev/null
+++ b/lib/P3D.ContentPipeline/Content/Effects/BasicEffectWithAlphaTest.fx
@@ -0,0 +1,832 @@
+//-----------------------------------------------------------------------------
+// BasicEffect.fx
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+#include "Macros.fxh"
+
+
+DECLARE_TEXTURE(Texture, 0);
+
+
+BEGIN_CONSTANTS
+
+    float4 DiffuseColor             _vs(c0)  _ps(c1)  _cb(c0);
+    float3 EmissiveColor            _vs(c1)  _ps(c2)  _cb(c1);
+    float3 SpecularColor            _vs(c2)  _ps(c3)  _cb(c2);
+    float  SpecularPower            _vs(c3)  _ps(c4)  _cb(c2.w);
+
+    float3 DirLight0Direction       _vs(c4)  _ps(c5)  _cb(c3);
+    float3 DirLight0DiffuseColor    _vs(c5)  _ps(c6)  _cb(c4);
+    float3 DirLight0SpecularColor   _vs(c6)  _ps(c7)  _cb(c5);
+
+    float3 DirLight1Direction       _vs(c7)  _ps(c8)  _cb(c6);
+    float3 DirLight1DiffuseColor    _vs(c8)  _ps(c9)  _cb(c7);
+    float3 DirLight1SpecularColor   _vs(c9)  _ps(c10) _cb(c8);
+
+    float3 DirLight2Direction       _vs(c10) _ps(c11) _cb(c9);
+    float3 DirLight2DiffuseColor    _vs(c11) _ps(c12) _cb(c10);
+    float3 DirLight2SpecularColor   _vs(c12) _ps(c13) _cb(c11);
+
+    float3 EyePosition              _vs(c13) _ps(c14) _cb(c12);
+
+    float3 FogColor                          _ps(c0)  _cb(c13);
+    float4 FogVector                _vs(c14)          _cb(c14);
+
+    float4x4 World                  _vs(c19)          _cb(c15);
+    float3x3 WorldInverseTranspose  _vs(c23)          _cb(c19);
+    
+    float AlphaTest                          _ps(c15) _cb(c20);
+
+MATRIX_CONSTANTS
+
+    float4x4 WorldViewProj          _vs(c15)          _cb(c0);
+
+END_CONSTANTS
+
+
+#include "Structures.fxh"
+#include "Common.fxh"
+#include "Lighting.fxh"
+
+
+// Vertex shader: basic.
+VSOutput VSBasic(VSInput vin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParams;
+    
+    return vout;
+}
+
+
+// Vertex shader: basic.
+VSOutput VSHWBasic(VSInput vin, VSHWInputInstance vhwin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position + vhwin.Position);
+    SetCommonVSOutputParams;
+    
+    return vout;
+}
+
+
+// Vertex shader: no fog.
+VSOutputNoFog VSBasicNoFog(VSInput vin)
+{
+    VSOutputNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    return vout;
+}
+
+
+// Vertex shader: no fog.
+VSOutputNoFog VSHWBasicNoFog(VSInput vin, VSHWInputInstance vhwin)
+{
+    VSOutputNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position + vhwin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex color.
+VSOutput VSBasicVc(VSInputVc vin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParams;
+    
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex color.
+VSOutput VSHWBasicVc(VSInputVc vin, VSHWInputInstance vhwin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position + vhwin.Position);
+    SetCommonVSOutputParams;
+    
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex color, no fog.
+VSOutputNoFog VSBasicVcNoFog(VSInputVc vin)
+{
+    VSOutputNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex color, no fog.
+VSOutputNoFog VSHWBasicVcNoFog(VSInputVc vin, VSHWInputInstance vhwin)
+{
+    VSOutputNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position + vhwin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: texture.
+VSOutputTx VSBasicTx(VSInputTx vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: texture.
+VSOutputTx VSHWBasicTx(VSInputTx vin, VSHWInputInstance vhwin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position + vhwin.Position);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: texture, no fog.
+VSOutputTxNoFog VSBasicTxNoFog(VSInputTx vin)
+{
+    VSOutputTxNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: texture, no fog.
+VSOutputTxNoFog VSHWBasicTxNoFog(VSInputTx vin, VSHWInputInstance vhwin)
+{
+    VSOutputTxNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position + vhwin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: texture + vertex color.
+VSOutputTx VSBasicTxVc(VSInputTxVc vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: texture + vertex color.
+VSOutputTx VSHWBasicTxVc(VSInputTxVc vin, VSHWInputInstance vhwin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position + vhwin.Position);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: texture + vertex color, no fog.
+VSOutputTxNoFog VSBasicTxVcNoFog(VSInputTxVc vin)
+{
+    VSOutputTxNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: texture + vertex color, no fog.
+VSOutputTxNoFog VSHWBasicTxVcNoFog(VSInputTxVc vin, VSHWInputInstance vhwin)
+{
+    VSOutputTxNoFog vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutput(vin.Position + vhwin.Position);
+    SetCommonVSOutputParamsNoFog;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting.
+VSOutput VSBasicVertexLighting(VSInputNm vin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting.
+VSOutput VSHWBasicVertexLighting(VSInputNm vin, VSHWInputInstance vhwin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position + vhwin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting + vertex color.
+VSOutput VSBasicVertexLightingVc(VSInputNmVc vin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting + vertex color.
+VSOutput VSHWBasicVertexLightingVc(VSInputNmVc vin, VSHWInputInstance vhwin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position + vhwin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting + texture.
+VSOutputTx VSBasicVertexLightingTx(VSInputNmTx vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting + texture.
+VSOutputTx VSHWBasicVertexLightingTx(VSInputNmTx vin, VSHWInputInstance vhwin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position + vhwin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting + texture + vertex color.
+VSOutputTx VSBasicVertexLightingTxVc(VSInputNmTxVc vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: vertex lighting + texture + vertex color.
+VSOutputTx VSHWBasicVertexLightingTxVc(VSInputNmTxVc vin, VSHWInputInstance vhwin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position + vhwin.Position, vin.Normal, 3);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: one light.
+VSOutput VSBasicOneLight(VSInputNm vin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    return vout;
+}
+
+
+// Vertex shader: one light.
+VSOutput VSHWBasicOneLight(VSInputNm vin, VSHWInputInstance vhwin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position + vhwin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    return vout;
+}
+
+
+// Vertex shader: one light + vertex color.
+VSOutput VSBasicOneLightVc(VSInputNmVc vin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: one light + vertex color.
+VSOutput VSHWBasicOneLightVc(VSInputNmVc vin, VSHWInputInstance vhwin)
+{
+    VSOutput vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position + vhwin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: one light + texture.
+VSOutputTx VSBasicOneLightTx(VSInputNmTx vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: one light + texture.
+VSOutputTx VSHWBasicOneLightTx(VSInputNmTx vin, VSHWInputInstance vhwin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position + vhwin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: one light + texture + vertex color.
+VSOutputTx VSBasicOneLightTxVc(VSInputNmTxVc vin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: one light + texture + vertex color.
+VSOutputTx VSHWBasicOneLightTxVc(VSInputNmTxVc vin, VSHWInputInstance vhwin)
+{
+    VSOutputTx vout;
+    
+    CommonVSOutput cout = ComputeCommonVSOutputWithLighting(vin.Position + vhwin.Position, vin.Normal, 1);
+    SetCommonVSOutputParams;
+    
+    vout.TexCoord = vin.TexCoord;
+    vout.Diffuse *= vin.Color;
+    
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting.
+VSOutputPixelLighting VSBasicPixelLighting(VSInputNm vin)
+{
+    VSOutputPixelLighting vout;
+    
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+
+    vout.Diffuse = float4(1, 1, 1, DiffuseColor.a);
+    
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting.
+VSOutputPixelLighting VSHWBasicPixelLighting(VSInputNm vin, VSHWInputInstance vhwin)
+{
+    VSOutputPixelLighting vout;
+    
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position + vhwin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+
+    vout.Diffuse = float4(1, 1, 1, DiffuseColor.a);
+    
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting + vertex color.
+VSOutputPixelLighting VSBasicPixelLightingVc(VSInputNmVc vin)
+{
+    VSOutputPixelLighting vout;
+    
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+    
+    vout.Diffuse.rgb = vin.Color.rgb;
+    vout.Diffuse.a = vin.Color.a * DiffuseColor.a;
+    
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting + vertex color.
+VSOutputPixelLighting VSHWBasicPixelLightingVc(VSInputNmVc vin, VSHWInputInstance vhwin)
+{
+    VSOutputPixelLighting vout;
+    
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position + vhwin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+    
+    vout.Diffuse.rgb = vin.Color.rgb;
+    vout.Diffuse.a = vin.Color.a * DiffuseColor.a;
+    
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting + texture.
+VSOutputPixelLightingTx VSBasicPixelLightingTx(VSInputNmTx vin)
+{
+    VSOutputPixelLightingTx vout;
+    
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+    
+    vout.Diffuse = float4(1, 1, 1, DiffuseColor.a);
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting + texture.
+VSOutputPixelLightingTx VSHWBasicPixelLightingTx(VSInputNmTx vin, VSHWInputInstance vhwin)
+{
+    VSOutputPixelLightingTx vout;
+    
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position + vhwin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+    
+    vout.Diffuse = float4(1, 1, 1, DiffuseColor.a);
+    vout.TexCoord = vin.TexCoord;
+
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting + texture + vertex color.
+VSOutputPixelLightingTx VSBasicPixelLightingTxVc(VSInputNmTxVc vin)
+{
+    VSOutputPixelLightingTx vout;
+    
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+    
+    vout.Diffuse.rgb = vin.Color.rgb;
+    vout.Diffuse.a = vin.Color.a * DiffuseColor.a;
+    vout.TexCoord = vin.TexCoord;
+    
+    return vout;
+}
+
+
+// Vertex shader: pixel lighting + texture + vertex color.
+VSOutputPixelLightingTx VSHWBasicPixelLightingTxVc(VSInputNmTxVc vin, VSHWInputInstance vhwin)
+{
+    VSOutputPixelLightingTx vout;
+    
+    CommonVSOutputPixelLighting cout = ComputeCommonVSOutputPixelLighting(vin.Position + vhwin.Position, vin.Normal);
+    SetCommonVSOutputParamsPixelLighting;
+    
+    vout.Diffuse.rgb = vin.Color.rgb;
+    vout.Diffuse.a = vin.Color.a * DiffuseColor.a;
+    vout.TexCoord = vin.TexCoord;
+    
+    return vout;
+}
+
+
+// Pixel shader: basic.
+float4 PSBasic(VSOutput pin) : SV_Target0
+{
+    float4 color = pin.Diffuse;
+
+    clip(color.a <= AlphaTest ? -1 : 1);
+    
+    ApplyFog(color, pin.Specular.w);
+    
+    return color;
+}
+
+
+// Pixel shader: no fog.
+float4 PSBasicNoFog(VSOutputNoFog pin) : SV_Target0
+{
+    float4 color = pin.Diffuse;
+
+    clip(color.a <= AlphaTest ? -1 : 1);
+
+    return color;
+}
+
+
+// Pixel shader: texture.
+float4 PSBasicTx(VSOutputTx pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+
+    clip(color.a <= AlphaTest ? -1 : 1);
+    
+    ApplyFog(color, pin.Specular.w);
+    
+    return color;
+}
+
+
+// Pixel shader: texture, no fog.
+float4 PSBasicTxNoFog(VSOutputTxNoFog pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+
+    clip(color.a <= AlphaTest ? -1 : 1);
+
+    return color;
+}
+
+
+// Pixel shader: vertex lighting.
+float4 PSBasicVertexLighting(VSOutput pin) : SV_Target0
+{
+    float4 color = pin.Diffuse;
+
+    clip(color.a <= AlphaTest ? -1 : 1);
+
+    AddSpecular(color, pin.Specular.rgb);
+    ApplyFog(color, pin.Specular.w);
+    
+    return color;
+}
+
+
+// Pixel shader: vertex lighting, no fog.
+float4 PSBasicVertexLightingNoFog(VSOutput pin) : SV_Target0
+{
+    float4 color = pin.Diffuse;
+
+    clip(color.a <= AlphaTest ? -1 : 1);
+    
+    AddSpecular(color, pin.Specular.rgb);
+    
+    return color;
+}
+
+
+// Pixel shader: vertex lighting + texture.
+float4 PSBasicVertexLightingTx(VSOutputTx pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+
+    clip(color.a <= AlphaTest ? -1 : 1);
+    
+    AddSpecular(color, pin.Specular.rgb);
+    ApplyFog(color, pin.Specular.w);
+    
+    return color;
+}
+
+
+// Pixel shader: vertex lighting + texture, no fog.
+float4 PSBasicVertexLightingTxNoFog(VSOutputTx pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+
+    clip(color.a <= AlphaTest ? -1 : 1);
+    
+    AddSpecular(color, pin.Specular.rgb);
+    
+    return color;
+}
+
+
+// Pixel shader: pixel lighting.
+float4 PSBasicPixelLighting(VSOutputPixelLighting pin) : SV_Target0
+{
+    float4 color = pin.Diffuse;
+
+    float3 eyeVector = normalize(EyePosition - pin.PositionWS.xyz);
+    float3 worldNormal = normalize(pin.NormalWS);
+    
+    ColorPair lightResult = ComputeLights(eyeVector, worldNormal, 3);
+
+    color.rgb *= lightResult.Diffuse;
+
+    clip(color.a <= AlphaTest ? -1 : 1);
+    
+    AddSpecular(color, lightResult.Specular);
+    ApplyFog(color, pin.PositionWS.w);
+    
+    return color;
+}
+
+
+// Pixel shader: pixel lighting + texture.
+float4 PSBasicPixelLightingTx(VSOutputPixelLightingTx pin) : SV_Target0
+{
+    float4 color = SAMPLE_TEXTURE(Texture, pin.TexCoord) * pin.Diffuse;
+    
+    float3 eyeVector = normalize(EyePosition - pin.PositionWS.xyz);
+    float3 worldNormal = normalize(pin.NormalWS);
+    
+    ColorPair lightResult = ComputeLights(eyeVector, worldNormal, 3);
+    
+    color.rgb *= lightResult.Diffuse;
+
+    clip(color.a <= AlphaTest ? -1 : 1);
+
+    AddSpecular(color, lightResult.Specular);
+    ApplyFog(color, pin.PositionWS.w);
+    
+    return color;
+}
+
+
+// NOTE: The order of the techniques here are
+// defined to match the indexing in BasicEffect.cs.
+
+TECHNIQUE( BasicEffect,								VSBasic,			PSBasic );
+TECHNIQUE( BasicEffect_NoFog,						VSBasicNoFog,		PSBasicNoFog );
+TECHNIQUE( BasicEffect_VertexColor,					VSBasicVc,			PSBasic );
+TECHNIQUE( BasicEffect_VertexColor_NoFog,			VSBasicVcNoFog,		PSBasicNoFog );
+TECHNIQUE( BasicEffect_Texture,						VSBasicTx,			PSBasicTx );
+TECHNIQUE( BasicEffect_Texture_NoFog,				VSBasicTxNoFog,		PSBasicTxNoFog );
+TECHNIQUE( BasicEffect_Texture_VertexColor,			VSBasicTxVc,		PSBasicTx );
+TECHNIQUE( BasicEffect_Texture_VertexColor_NoFog,	VSBasicTxVcNoFog,	PSBasicTxNoFog );
+
+TECHNIQUE( BasicEffect_VertexLighting,								VSBasicVertexLighting,		PSBasicVertexLighting );
+TECHNIQUE( BasicEffect_VertexLighting_NoFog,						VSBasicVertexLighting,		PSBasicVertexLightingNoFog );
+TECHNIQUE( BasicEffect_VertexLighting_VertexColor,					VSBasicVertexLightingVc,	PSBasicVertexLighting );
+TECHNIQUE( BasicEffect_VertexLighting_VertexColor_NoFog,			VSBasicVertexLightingVc,	PSBasicVertexLightingNoFog );
+TECHNIQUE( BasicEffect_VertexLighting_Texture,						VSBasicVertexLightingTx,	PSBasicVertexLightingTx );
+TECHNIQUE( BasicEffect_VertexLighting_Texture_NoFog,				VSBasicVertexLightingTx,	PSBasicVertexLightingTxNoFog );
+TECHNIQUE( BasicEffect_VertexLighting_Texture_VertexColor,			VSBasicVertexLightingTxVc,	PSBasicVertexLightingTx );
+TECHNIQUE( BasicEffect_VertexLighting_Texture_VertexColor_NoFog,	VSBasicVertexLightingTxVc,	PSBasicVertexLightingTxNoFog );
+
+TECHNIQUE( BasicEffect_OneLight,							VSBasicOneLight,		PSBasicVertexLighting );
+TECHNIQUE( BasicEffect_OneLight_NoFog,						VSBasicOneLight,		PSBasicVertexLightingNoFog );
+TECHNIQUE( BasicEffect_OneLight_VertexColor,				VSBasicOneLightVc,		PSBasicVertexLighting );
+TECHNIQUE( BasicEffect_OneLight_VertexColor_NoFog,			VSBasicOneLightVc,		PSBasicVertexLightingNoFog );
+TECHNIQUE( BasicEffect_OneLight_Texture,					VSBasicOneLightTx,		PSBasicVertexLightingTx );
+TECHNIQUE( BasicEffect_OneLight_Texture_NoFog,				VSBasicOneLightTx,		PSBasicVertexLightingTxNoFog );
+TECHNIQUE( BasicEffect_OneLight_Texture_VertexColor,		VSBasicOneLightTxVc,	PSBasicVertexLightingTx );
+TECHNIQUE( BasicEffect_OneLight_Texture_VertexColor_NoFog,	VSBasicOneLightTxVc,	PSBasicVertexLightingTxNoFog );
+
+TECHNIQUE( BasicEffect_PixelLighting,							VSBasicPixelLighting,		PSBasicPixelLighting );
+TECHNIQUE( BasicEffect_PixelLighting_NoFog,						VSBasicPixelLighting,		PSBasicPixelLighting );
+TECHNIQUE( BasicEffect_PixelLighting_VertexColor,				VSBasicPixelLightingVc,		PSBasicPixelLighting );
+TECHNIQUE( BasicEffect_PixelLighting_VertexColor_NoFog,			VSBasicPixelLightingVc,		PSBasicPixelLighting );
+TECHNIQUE( BasicEffect_PixelLighting_Texture,					VSBasicPixelLightingTx,		PSBasicPixelLightingTx );
+TECHNIQUE( BasicEffect_PixelLighting_Texture_NoFog,				VSBasicPixelLightingTx,		PSBasicPixelLightingTx );
+TECHNIQUE( BasicEffect_PixelLighting_Texture_VertexColor,		VSBasicPixelLightingTxVc,	PSBasicPixelLightingTx );
+TECHNIQUE( BasicEffect_PixelLighting_Texture_VertexColor_NoFog,	VSBasicPixelLightingTxVc,	PSBasicPixelLightingTx );
+
+TECHNIQUE( BasicEffect_HardwareInstancing,								VSHWBasic,			PSBasic );
+TECHNIQUE( BasicEffect_HardwareInstancing_NoFog,						VSHWBasicNoFog,		PSBasicNoFog );
+TECHNIQUE( BasicEffect_HardwareInstancing_VertexColor,					VSHWBasicVc,		PSBasic );
+TECHNIQUE( BasicEffect_HardwareInstancing_VertexColor_NoFog,			VSHWBasicVcNoFog,	PSBasicNoFog );
+TECHNIQUE( BasicEffect_HardwareInstancing_Texture,						VSHWBasicTx,		PSBasicTx );
+TECHNIQUE( BasicEffect_HardwareInstancing_Texture_NoFog,				VSHWBasicTxNoFog,	PSBasicTxNoFog );
+TECHNIQUE( BasicEffect_HardwareInstancing_Texture_VertexColor,			VSHWBasicTxVc,		PSBasicTx );
+TECHNIQUE( BasicEffect_HardwareInstancing_Texture_VertexColor_NoFog,	VSHWBasicTxVcNoFog, PSBasicTxNoFog );
+
+TECHNIQUE( BasicEffect_HardwareInstancing_VertexLighting,							VSHWBasicVertexLighting,	    PSBasicVertexLighting );
+TECHNIQUE( BasicEffect_HardwareInstancing_VertexLighting_NoFog,						VSHWBasicVertexLighting,	    PSBasicVertexLightingNoFog );
+TECHNIQUE( BasicEffect_HardwareInstancing_VertexLighting_VertexColor,				VSHWBasicVertexLightingVc,	    PSBasicVertexLighting );
+TECHNIQUE( BasicEffect_HardwareInstancing_VertexLighting_VertexColor_NoFog,			VSHWBasicVertexLightingVc,	    PSBasicVertexLightingNoFog );
+TECHNIQUE( BasicEffect_HardwareInstancing_VertexLighting_Texture,					VSHWBasicVertexLightingTx,	    PSBasicVertexLightingTx );
+TECHNIQUE( BasicEffect_HardwareInstancing_VertexLighting_Texture_NoFog,				VSHWBasicVertexLightingTx,	    PSBasicVertexLightingTxNoFog );
+TECHNIQUE( BasicEffect_HardwareInstancing_VertexLighting_Texture_VertexColor,		VSHWBasicVertexLightingTxVc,    PSBasicVertexLightingTx );
+TECHNIQUE( BasicEffect_HardwareInstancing_VertexLighting_Texture_VertexColor_NoFog, VSHWBasicVertexLightingTxVc,    PSBasicVertexLightingTxNoFog );
+
+TECHNIQUE( BasicEffect_HardwareInstancing_OneLight,							    VSHWBasicOneLight,		PSBasicVertexLighting );
+TECHNIQUE( BasicEffect_HardwareInstancing_OneLight_NoFog,						VSHWBasicOneLight,		PSBasicVertexLightingNoFog );
+TECHNIQUE( BasicEffect_HardwareInstancing_OneLight_VertexColor,				    VSHWBasicOneLightVc,	PSBasicVertexLighting );
+TECHNIQUE( BasicEffect_HardwareInstancing_OneLight_VertexColor_NoFog,			VSHWBasicOneLightVc,	PSBasicVertexLightingNoFog );
+TECHNIQUE( BasicEffect_HardwareInstancing_OneLight_Texture,					    VSHWBasicOneLightTx,	PSBasicVertexLightingTx );
+TECHNIQUE( BasicEffect_HardwareInstancing_OneLight_Texture_NoFog,				VSHWBasicOneLightTx,	PSBasicVertexLightingTxNoFog );
+TECHNIQUE( BasicEffect_HardwareInstancing_OneLight_Texture_VertexColor,		    VSHWBasicOneLightTxVc,  PSBasicVertexLightingTx );
+TECHNIQUE( BasicEffect_HardwareInstancing_OneLight_Texture_VertexColor_NoFog,	VSHWBasicOneLightTxVc,  PSBasicVertexLightingTxNoFog );
+
+TECHNIQUE( BasicEffect_HardwareInstancing_PixelLighting,							VSHWBasicPixelLighting,		PSBasicPixelLighting );
+TECHNIQUE( BasicEffect_HardwareInstancing_PixelLighting_NoFog,						VSHWBasicPixelLighting,		PSBasicPixelLighting );
+TECHNIQUE( BasicEffect_HardwareInstancing_PixelLighting_VertexColor,				VSHWBasicPixelLightingVc,	PSBasicPixelLighting );
+TECHNIQUE( BasicEffect_HardwareInstancing_PixelLighting_VertexColor_NoFog,			VSHWBasicPixelLightingVc,	PSBasicPixelLighting );
+TECHNIQUE( BasicEffect_HardwareInstancing_PixelLighting_Texture,					VSHWBasicPixelLightingTx,	PSBasicPixelLightingTx );
+TECHNIQUE( BasicEffect_HardwareInstancing_PixelLighting_Texture_NoFog,				VSHWBasicPixelLightingTx,   PSBasicPixelLightingTx );
+TECHNIQUE( BasicEffect_HardwareInstancing_PixelLighting_Texture_VertexColor,		VSHWBasicPixelLightingTxVc,	PSBasicPixelLightingTx );
+TECHNIQUE( BasicEffect_HardwareInstancing_PixelLighting_Texture_VertexColor_NoFog,	VSHWBasicPixelLightingTxVc, PSBasicPixelLightingTx );
\ No newline at end of file
diff --git a/lib/P3D.ContentPipeline/Content/Effects/Common.fxh b/lib/P3D.ContentPipeline/Content/Effects/Common.fxh
new file mode 100644
index 000000000..33f121be0
--- /dev/null
+++ b/lib/P3D.ContentPipeline/Content/Effects/Common.fxh
@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------------
+// Common.fxh
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+
+float ComputeFogFactor(float4 position)
+{
+    return saturate(dot(position, FogVector));
+}
+
+
+void ApplyFog(inout float4 color, float fogFactor)
+{
+    color.rgb = lerp(color.rgb, FogColor * color.a, fogFactor);
+}
+
+
+void AddSpecular(inout float4 color, float3 specular)
+{
+    color.rgb += specular * color.a;
+}
+
+
+struct CommonVSOutput
+{
+    float4 Pos_ps;
+    float4 Diffuse;
+    float3 Specular;
+    float  FogFactor;
+};
+
+
+CommonVSOutput ComputeCommonVSOutput(float4 position)
+{
+    CommonVSOutput vout;
+    
+    vout.Pos_ps = mul(position, WorldViewProj);
+    vout.Diffuse = DiffuseColor;
+    vout.Specular = 0;
+    vout.FogFactor = ComputeFogFactor(position);
+    
+    return vout;
+}
+
+
+#define SetCommonVSOutputParams \
+    vout.PositionPS = cout.Pos_ps; \
+    vout.Diffuse = cout.Diffuse; \
+    vout.Specular = float4(cout.Specular, cout.FogFactor);
+
+
+#define SetCommonVSOutputParamsNoFog \
+    vout.PositionPS = cout.Pos_ps; \
+    vout.Diffuse = cout.Diffuse;
+
diff --git a/lib/P3D.ContentPipeline/Content/Effects/Lighting.fxh b/lib/P3D.ContentPipeline/Content/Effects/Lighting.fxh
new file mode 100644
index 000000000..6b82db49d
--- /dev/null
+++ b/lib/P3D.ContentPipeline/Content/Effects/Lighting.fxh
@@ -0,0 +1,94 @@
+//-----------------------------------------------------------------------------
+// Lighting.fxh
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+
+struct ColorPair
+{
+    float3 Diffuse;
+    float3 Specular;
+};
+
+
+ColorPair ComputeLights(float3 eyeVector, float3 worldNormal, uniform int numLights)
+{
+    float3x3 lightDirections = 0;
+    float3x3 lightDiffuse = 0;
+    float3x3 lightSpecular = 0;
+    float3x3 halfVectors = 0;
+    
+    [unroll]
+    for (int i = 0; i < numLights; i++)
+    {
+        lightDirections[i] = float3x3(DirLight0Direction,     DirLight1Direction,     DirLight2Direction)    [i];
+        lightDiffuse[i]    = float3x3(DirLight0DiffuseColor,  DirLight1DiffuseColor,  DirLight2DiffuseColor) [i];
+        lightSpecular[i]   = float3x3(DirLight0SpecularColor, DirLight1SpecularColor, DirLight2SpecularColor)[i];
+        
+        halfVectors[i] = normalize(eyeVector - lightDirections[i]);
+    }
+
+    float3 dotL = mul(-lightDirections, worldNormal);
+    float3 dotH = mul(halfVectors, worldNormal);
+    
+    float3 zeroL = step(float3(0,0,0), dotL);
+
+    float3 diffuse  = zeroL * dotL;
+    float3 specular = pow(max(dotH, 0) * zeroL, SpecularPower);
+
+    ColorPair result;
+    
+    result.Diffuse  = mul(diffuse,  lightDiffuse)  * DiffuseColor.rgb + EmissiveColor;
+    result.Specular = mul(specular, lightSpecular) * SpecularColor;
+
+    return result;
+}
+
+
+CommonVSOutput ComputeCommonVSOutputWithLighting(float4 position, float3 normal, uniform int numLights)
+{
+    CommonVSOutput vout;
+    
+    float4 pos_ws = mul(position, World);
+    float3 eyeVector = normalize(EyePosition - pos_ws.xyz);
+    float3 worldNormal = normalize(mul(normal, WorldInverseTranspose));
+
+    ColorPair lightResult = ComputeLights(eyeVector, worldNormal, numLights);
+    
+    vout.Pos_ps = mul(position, WorldViewProj);
+    vout.Diffuse = float4(lightResult.Diffuse, DiffuseColor.a);
+    vout.Specular = lightResult.Specular;
+    vout.FogFactor = ComputeFogFactor(position);
+    
+    return vout;
+}
+
+
+struct CommonVSOutputPixelLighting
+{
+    float4 Pos_ps;
+    float3 Pos_ws;
+    float3 Normal_ws;
+    float  FogFactor;
+};
+
+
+CommonVSOutputPixelLighting ComputeCommonVSOutputPixelLighting(float4 position, float3 normal)
+{
+    CommonVSOutputPixelLighting vout;
+    
+    vout.Pos_ps = mul(position, WorldViewProj);
+    vout.Pos_ws = mul(position, World).xyz;
+    vout.Normal_ws = normalize(mul(normal, WorldInverseTranspose));
+    vout.FogFactor = ComputeFogFactor(position);
+    
+    return vout;
+}
+
+
+#define SetCommonVSOutputParamsPixelLighting \
+    vout.PositionPS = cout.Pos_ps; \
+    vout.PositionWS = float4(cout.Pos_ws, cout.FogFactor); \
+    vout.NormalWS = cout.Normal_ws;
diff --git a/lib/P3D.ContentPipeline/Content/Effects/Macros.fxh b/lib/P3D.ContentPipeline/Content/Effects/Macros.fxh
new file mode 100644
index 000000000..7b1d31e05
--- /dev/null
+++ b/lib/P3D.ContentPipeline/Content/Effects/Macros.fxh
@@ -0,0 +1,61 @@
+//-----------------------------------------------------------------------------
+// Macros.fxh
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+#ifdef SM4
+
+// Macros for targetting shader model 4.0 (DX11)
+
+#define TECHNIQUE(name, vsname, psname ) \
+	technique name { pass { VertexShader = compile vs_4_0_level_9_1 vsname (); PixelShader = compile ps_4_0_level_9_1 psname(); } }
+
+#define BEGIN_CONSTANTS     cbuffer Parameters : register(b0) {
+#define MATRIX_CONSTANTS
+#define END_CONSTANTS       };
+
+#define _vs(r)
+#define _ps(r)
+#define _cb(r)
+
+#define DECLARE_TEXTURE(Name, index) \
+    Texture2D<float4> Name : register(t##index); \
+    sampler Name##Sampler : register(s##index)
+
+#define DECLARE_CUBEMAP(Name, index) \
+    TextureCube<float4> Name : register(t##index); \
+    sampler Name##Sampler : register(s##index)
+
+#define SAMPLE_TEXTURE(Name, texCoord)  Name.Sample(Name##Sampler, texCoord)
+#define SAMPLE_CUBEMAP(Name, texCoord)  Name.Sample(Name##Sampler, texCoord)
+
+
+#else
+
+
+// Macros for targetting shader model 2.0 (DX9)
+
+#define TECHNIQUE(name, vsname, psname ) \
+	technique name { pass { VertexShader = compile vs_2_0 vsname (); PixelShader = compile ps_2_0 psname(); } }
+
+#define BEGIN_CONSTANTS
+#define MATRIX_CONSTANTS
+#define END_CONSTANTS
+
+#define _vs(r)  : register(vs, r)
+#define _ps(r)  : register(ps, r)
+#define _cb(r)
+
+#define DECLARE_TEXTURE(Name, index) \
+    sampler2D Name : register(s##index);
+
+#define DECLARE_CUBEMAP(Name, index) \
+    samplerCUBE Name : register(s##index);
+
+#define SAMPLE_TEXTURE(Name, texCoord)  tex2D(Name, texCoord)
+#define SAMPLE_CUBEMAP(Name, texCoord)  texCUBE(Name, texCoord)
+
+
+#endif
diff --git a/lib/P3D.ContentPipeline/Content/Effects/Structures.fxh b/lib/P3D.ContentPipeline/Content/Effects/Structures.fxh
new file mode 100644
index 000000000..817b557a9
--- /dev/null
+++ b/lib/P3D.ContentPipeline/Content/Effects/Structures.fxh
@@ -0,0 +1,166 @@
+//-----------------------------------------------------------------------------
+// Structurs.fxh
+//
+// Microsoft XNA Community Game Platform
+// Copyright (C) Microsoft Corporation. All rights reserved.
+//-----------------------------------------------------------------------------
+
+
+// Vertex shader input structures.
+
+struct VSHWInputInstance
+{
+    float4 Position : POSITION1;
+};
+
+struct VSInput
+{
+    float4 Position : POSITION0;
+};
+
+struct VSInputVc
+{
+    float4 Position : POSITION0;
+    float4 Color    : COLOR;
+};
+
+struct VSInputTx
+{
+    float4 Position : POSITION0;
+    float2 TexCoord : TEXCOORD;
+};
+
+struct VSInputTxVc
+{
+    float4 Position : POSITION0;
+    float2 TexCoord : TEXCOORD;
+    float4 Color    : COLOR;
+};
+
+struct VSInputNm
+{
+    float4 Position : POSITION0;
+    float3 Normal   : NORMAL;
+};
+
+struct VSInputNmVc
+{
+    float4 Position : POSITION0;
+    float3 Normal   : NORMAL;
+    float4 Color    : COLOR;
+};
+
+struct VSInputNmTx
+{
+    float4 Position : POSITION0;
+    float3 Normal   : NORMAL;
+    float2 TexCoord : TEXCOORD;
+};
+
+struct VSInputNmTxVc
+{
+    float4 Position : POSITION0;
+    float3 Normal   : NORMAL;
+    float2 TexCoord : TEXCOORD;
+    float4 Color    : COLOR;
+};
+
+struct VSInputTx2
+{
+    float4 Position  : POSITION0;
+    float2 TexCoord  : TEXCOORD0;
+    float2 TexCoord2 : TEXCOORD1;
+};
+
+struct VSInputTx2Vc
+{
+    float4 Position  : POSITION0;
+    float2 TexCoord  : TEXCOORD0;
+    float2 TexCoord2 : TEXCOORD1;
+    float4 Color     : COLOR;
+};
+
+struct VSInputNmTxWeights
+{
+    float4 Position : POSITION0;
+    float3 Normal   : NORMAL0;
+    float2 TexCoord : TEXCOORD0;
+    uint4  Indices  : BLENDINDICES0;
+    float4 Weights  : BLENDWEIGHT0;
+};
+
+
+
+// Vertex shader output structures.
+
+struct VSOutput
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+    float4 Specular   : COLOR1;
+};
+
+struct VSOutputNoFog
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+};
+
+struct VSOutputTx
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+    float4 Specular   : COLOR1;
+    float2 TexCoord   : TEXCOORD0;
+};
+
+struct VSOutputTxNoFog
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+    float2 TexCoord   : TEXCOORD0;
+};
+
+struct VSOutputPixelLighting
+{
+    float4 PositionPS : SV_Position;
+    float4 PositionWS : TEXCOORD0;
+    float3 NormalWS   : TEXCOORD1;
+    float4 Diffuse    : COLOR0;
+};
+
+struct VSOutputPixelLightingTx
+{
+    float4 PositionPS : SV_Position;
+    float2 TexCoord   : TEXCOORD0;
+    float4 PositionWS : TEXCOORD1;
+    float3 NormalWS   : TEXCOORD2;
+    float4 Diffuse    : COLOR0;
+};
+
+struct VSOutputTx2
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+    float4 Specular   : COLOR1;
+    float2 TexCoord   : TEXCOORD0;
+    float2 TexCoord2  : TEXCOORD1;
+};
+
+struct VSOutputTx2NoFog
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+    float2 TexCoord   : TEXCOORD0;
+    float2 TexCoord2  : TEXCOORD1;
+};
+
+struct VSOutputTxEnvMap
+{
+    float4 PositionPS : SV_Position;
+    float4 Diffuse    : COLOR0;
+    float4 Specular   : COLOR1;
+    float2 TexCoord   : TEXCOORD0;
+    float3 EnvCoord   : TEXCOORD1;
+};
+