Increase maximum window width limit to 8k

Fix issue with MapTrack for actors
Add vehicle telemetry logging debug option
2021-08-26 20:22:10 +02:00 · 2021-08-26 20:22:02 +02:00 · 2021-08-21 13:48:18 +02:00 · 2021-08-21 13:35:32 +02:00 · 2021-08-21 13:16:19 +02:00 · 2021-08-21 13:16:14 +02:00
3346 changed files with 151013 additions and 92448 deletions
@@ -0,0 +1,43 @@
+name: Build Linux
+on: [push, pull_request]
+
+jobs:
+
+  # Editor
+  editor-linux:
+    name: Editor (Linux, Development x64)
+    runs-on: "ubuntu-20.04"
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v2
+    - name: Checkout LFS
+      run: |
+        git lfs version
+        git lfs pull
+    - name: Install dependencies
+      run: |
+        sudo rm -f /etc/apt/sources.list.d/*
+        sudo cp -f .github/workflows/build_linux_sources.list /etc/apt/sources.list
+        sudo apt-get update
+        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev build-essential gettext libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev
+    - name: Build
+      run: |
+        ./Development/Scripts/Linux/CallBuildTool.sh -build -log -arch=x64 -platform=Linux -configuration=Development -buildtargets=FlaxEditor
+
+  # Game
+  game-linux:
+    name: Game (Linux, Release x64)
+    runs-on: "ubuntu-20.04"
+    steps:
+    - name: Install dependencies
+      run: |
+        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev
+    - name: Checkout repo
+      uses: actions/checkout@v2
+    - name: Checkout LFS
+      run: |
+        git lfs version
+        git lfs pull
+    - name: Build
+      run: |
+        ./Development/Scripts/Linux/CallBuildTool.sh -build -log -arch=x64 -platform=Linux -configuration=Release -buildtargets=FlaxGame
@@ -0,0 +1,4 @@
+deb http://archive.ubuntu.com/ubuntu/ focal main restricted universe multiverse
+deb http://archive.ubuntu.com/ubuntu/ focal-updates main restricted universe multiverse
+deb http://archive.ubuntu.com/ubuntu/ focal-security main restricted universe multiverse
+deb http://archive.ubuntu.com/ubuntu/ focal-backports main restricted universe multiverse
@@ -0,0 +1,34 @@
+name: Build Windows
+on: [push, pull_request]
+
+jobs:
+
+  # Editor
+  editor-windows:
+    name: Editor (Windows, Development x64)
+    runs-on: "windows-latest"
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v2
+    - name: Checkout LFS
+      run: |
+        git lfs version
+        git lfs pull
+    - name: Build
+      run: |
+        .\Development\Scripts\Windows\CallBuildTool.bat -build -log -arch=x64 -platform=Windows -configuration=Development -buildtargets=FlaxEditor
+
+  # Game
+  game-windows:
+    name: Game (Windows, Release x64)
+    runs-on: "windows-latest"
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v2
+    - name: Checkout LFS
+      run: |
+        git lfs version
+        git lfs pull
+    - name: Build
+      run: |
+        .\Development\Scripts\Windows\CallBuildTool.bat -build -log -arch=x64 -platform=Windows -configuration=Release -buildtargets=FlaxGame
@@ -0,0 +1,100 @@
+name: Continuous Deployment
+on:
+  schedule:
+    - cron: '15 4 * * *'
+  workflow_dispatch:
+
+jobs:
+
+  # Windows
+  package-windows-editor:
+    name: Editor (Windows)
+    runs-on: "windows-latest"
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v2
+    - name: Checkout LFS
+      run: |
+        git lfs version
+        git lfs pull
+    - name: Build
+      run: |
+        .\PackageEditor.bat -arch=x64 -platform=Windows -deployOutput=Output
+    - name: Upload
+      uses: actions/upload-artifact@v2
+      with:
+        name: Windows-Editor
+        path: Output/Editor.zip
+    - name: Upload
+      uses: actions/upload-artifact@v2
+      with:
+        name: Windows-EditorDebugSymbols
+        path: Output/EditorDebugSymbols.zip
+  package-windows-game:
+    name: Game (Windows)
+    runs-on: "windows-latest"
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v2
+    - name: Checkout LFS
+      run: |
+        git lfs version
+        git lfs pull
+    - name: Build
+      run: |
+        .\PackagePlatforms.bat -arch=x64 -platform=Windows -deployOutput=Output
+    - name: Upload
+      uses: actions/upload-artifact@v2
+      with:
+        name: Windows-Game
+        path: Output/Windows.zip
+
+  # Linux
+  package-linux-editor:
+    name: Editor (Linux)
+    runs-on: "ubuntu-20.04"
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v2
+    - name: Checkout LFS
+      run: |
+        git lfs version
+        git lfs pull
+    - name: Install dependencies
+      run: |
+        sudo rm -f /etc/apt/sources.list.d/*
+        sudo cp -f .github/workflows/build_linux_sources.list /etc/apt/sources.list
+        sudo apt-get update
+        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev build-essential gettext libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev
+    - name: Build
+      run: |
+        ./PackageEditor.sh -arch=x64 -platform=Linux -deployOutput=Output
+    - name: Upload
+      uses: actions/upload-artifact@v2
+      with:
+        name: Linux-Editor
+        path: Output/FlaxEditorLinux.zip
+  package-linux-game:
+    name: Game (Linux)
+    runs-on: "ubuntu-20.04"
+    steps:
+    - name: Checkout repo
+      uses: actions/checkout@v2
+    - name: Checkout LFS
+      run: |
+        git lfs version
+        git lfs pull
+    - name: Install dependencies
+      run: |
+        sudo rm -f /etc/apt/sources.list.d/*
+        sudo cp -f .github/workflows/build_linux_sources.list /etc/apt/sources.list
+        sudo apt-get update
+        sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev build-essential gettext libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev
+    - name: Build
+      run: |
+        ./PackagePlatforms.sh -arch=x64 -platform=Linux -deployOutput=Output
+    - name: Upload
+      uses: actions/upload-artifact@v2
+      with:
+        name: Linux-Game
+        path: Output/Linux.zip
@@ -7,7 +7,9 @@ Cache/
 Binaries/
 Logs/
 Source/*.csproj
+/Package_*/
 !Source/Engine/Debug
+/Source/Platforms/Editor/Linux/Mono/etc/mono/registry

 # User-specific files
 *.suo
@@ -22,11 +24,6 @@ Source/*.csproj
 *.VisualState.xml
 TestResult.xml

-# Build Results of an ATL Project
-[Dd]ebugPS/
-[Rr]eleasePS/
-dlldata.c
-
 # NuGet Packages Directory
 packages/**/*
 !packages/repositories.config
@@ -56,9 +53,6 @@ packages/**/*
 *.svclog
 *.scc

-# Chutzpah Test files
-_Chutzpah*
-
 # Visual C++ cache files
 ipch/
 *.aps
@@ -72,12 +66,6 @@ ipch/
 *.vsp
 *.vspx

-# TFS 2012 Local Workspace
-$tf/
-
-# Guidance Automation Toolkit
-*.gpState
-
 # ReSharper is a .NET coding add-in
 _ReSharper*/
 *.[Rr]e[Ss]harper
@@ -100,9 +88,6 @@ _NCrunch_*
 *.mm.*
 AutoTest.Net/

-# Web workbench (sass)
-.sass-cache/
-
 # Installshield output folder
 [Ee]xpress/

@@ -149,32 +134,9 @@ ClientBin/
 *.publishsettings
 node_modules/

-# RIA/Silverlight projects
-Generated_Code/
-
-# Backup & report files from converting an old project files
-_UpgradeReport_Files/
-Backup*/
-UpgradeLog*.XML
-UpgradeLog*.htm
-
-# SQL Server files
-*.mdf
-*.ldf
-
-# Business Intelligence projects
-*.rdl.data
-*.bim.layout
-*.bim_*.settings
-
 # Microsoft Fakes
 FakesAssemblies/

-# LightSwitch generated files
-GeneratedArtifacts/
-_Pvt_Extensions/
-ModelManifest.xml
-
 # IDE files
 *.VC.db
 enc_temp_folder/
@@ -185,3 +147,4 @@ obj/
 *.vcxproj.filters
 .vscode/
 *.code-workspace
+
@@ -1,3 +1,4 @@
 # Redirect to our own Git LFS server
 [lfs]
 url="https://gitlab.flaxengine.com/flax/flaxengine.git/info/lfs"
+locksverify = false
@@ -0,0 +1,50 @@
+# How to contribute to the FlaxEngine
+
+For any questions, suggestions or help join our discord!
+
+<a href="https://flaxengine.com/discord"><img src="https://discordapp.com/api/guilds/437989205315158016/widget.png"/></a>
+
+Want to see whats planned for Flax?
+
+Go check out our [Trello](https://trello.com/b/NQjLXRCP/flax-roadmap).
+
+## **Found a bug?**
+
+* Avoid opening any new issues without having checked if your problem has already been reported. If there are no currently open issues that fit your problem's description, feel free to [add it](https://github.com/FlaxEngine/FlaxEngine/issues/new).
+
+* When writing an issue make sure to include a clear title and description as well as having filled out all the necessary information, depending on the severity of the issue also include the necessary log files and minidump.
+
+* Try to following the given template when writing a new issue if possible.
+
+## **Want to contribute?**
+  
+* Fork the FlaxEngine, create a new branch and push your changes there. Then, create a pull request.
+  
+* When creating a PR for fixing an issue/bug make sure to describe as to what led to the fix for better understanding, for small and obvious fixes this is not really needed. 
+  However make sure to mention the relevant issue where it was first reported if possible.
+  
+* For feature PR's the first thing you should evaluate is the value of your contribution, as in, what would it bring to this engine? Is it really required?
+  If its a small change you could preferably suggest it to us on our discord, else feel free to open up a PR for it.
+  
+* Ensure when creating a PR that your contribution is well explained with a adequate description and title.
+
+* Generally, good code quality is expected, make sure your contribution works as intended and is appropriately commented where necessary.
+
+
+Thank you for taking interest in contributing to Flax!
+
+## **Common issues**
+
+Below are some common issues that someone working with the FlaxEngine source code might run into. Hopefully some of those issues will get fixed in the future. If you know how, please contribute!
+
+* Missing MSVC toolset
+  * Install it through the Visual Studio Installer
+* Building or attaching fails
+  * Run `GenerateProjectFiles.bat`
+  * Rebuild `Flax.Build`
+  * Make sure that there isn't a stray FlaxEngine process running in the background
+  * First start Flax and then attach the C# debugger
+  * Configure the C# FlaxEngine project by going into the project properties, then the debug tab and selecting "Start external program" `Flax\FlaxEngine\Binaries\Editor\Win64\Debug\FlaxEditor.exe`
+    * Then you can also set command line arguments such as `-project "C:\Users\PROFILE\Documents\Flax Projects\FlaxSamples\BasicTemplate"`
+* Git LFS
+  * Push with `git push --no-verify`
@@ -108,16 +108,14 @@ float4 GetVertexColor(MaterialInput input)
 	return 1;
 }

+@8
+
 // Get material properties function (for pixel shader)
 Material GetMaterialPS(MaterialInput input)
 {
@4
 }

-// Programmatically set the line number after all the material inputs which have a variable number of line endings
-// This allows shader error line numbers after this point to be the same regardless of which material is being compiled
-#line 1000
-
 // Input macro specified by the material: DECAL_BLEND_MODE

 #define DECAL_BLEND_MODE_TRANSLUCENT 0
@@ -160,10 +158,7 @@ void PS_Decal(
 	float3 positionWS = positionHS.xyz / positionHS.w;
 	float3 positionOS = mul(float4(positionWS, 1), InvWorld).xyz;

-	// Clip content outside the decal
 	clip(0.5 - abs(positionOS.xyz));
-
-	// By default, map textures using the vectors perpendicular to the projection direction
 	float2 decalUVs = positionOS.xz + 0.5f;

 	// Setup material input
@@ -199,19 +194,21 @@ void PS_Decal(
 	Out2 = float4(material.Emissive, material.Opacity);
 #if USE_NORMAL
 	// GBuffer1
-	Out3 = float4(material.WorldNormal * 0.5f + 0.5f, 1);
+	Out3 = float4(material.WorldNormal * 0.5f + 0.5f, material.Opacity);
 #endif
 #elif USE_NORMAL
 	// GBuffer1
-	Out2 = float4(material.WorldNormal * 0.5f + 0.5f, 1);
+	Out2 = float4(material.WorldNormal * 0.5f + 0.5f, material.Opacity);
 #endif
 #elif DECAL_BLEND_MODE == DECAL_BLEND_MODE_STAIN
 	Out0 = float4(material.Color, material.Opacity);
 #elif DECAL_BLEND_MODE == DECAL_BLEND_MODE_NORMAL
-	Out0 = float4(material.WorldNormal * 0.5f + 0.5f, 1);
+	Out0 = float4(material.WorldNormal * 0.5f + 0.5f, material.Opacity);
 #elif DECAL_BLEND_MODE == DECAL_BLEND_MODE_EMISSIVE
 	Out0 = float4(material.Emissive * material.Opacity, material.Opacity);
 #else
 	#error "Invalid decal blending mode"
 #endif
 }
+
+@9
@@ -0,0 +1,377 @@
+// File generated by Flax Materials Editor
+// Version: @0
+
+#define MATERIAL 1
+@3
+#include "./Flax/Common.hlsl"
+#include "./Flax/MaterialCommon.hlsl"
+#include "./Flax/GBufferCommon.hlsl"
+@7
+// Primary constant buffer (with additional material parameters)
+META_CB_BEGIN(0, Data)
+float4x4 ViewProjectionMatrix;
+float4x4 WorldMatrix;
+float4x4 LocalMatrix;
+float4x4 ViewMatrix;
+float3 ViewPos;
+float ViewFar;
+float3 ViewDir;
+float TimeParam;
+float4 ViewInfo;
+float4 ScreenSize;
+float3 Dummy0;
+float WorldDeterminantSign;
+float MeshMinZ;
+float Segment;
+float ChunksPerSegment;
+float PerInstanceRandom;
+float4 TemporalAAJitter;
+float3 GeometrySize;
+float MeshMaxZ;
+@1META_CB_END
+
+// Shader resources
+@2
+// The spline deformation buffer (stored as 4x3, 3 float4 behind each other)
+Buffer<float4> SplineDeformation : register(t0);
+
+// Geometry data passed though the graphics rendering stages up to the pixel shader
+struct GeometryData
+{
+	float3 WorldPosition : TEXCOORD0;
+	float2 TexCoord : TEXCOORD1;
+#if USE_VERTEX_COLOR
+	half4 VertexColor : COLOR;
+#endif
+	float3 WorldNormal : TEXCOORD2;
+	float4 WorldTangent : TEXCOORD3;
+};
+
+// Interpolants passed from the vertex shader
+struct VertexOutput
+{
+	float4 Position : SV_Position;
+	GeometryData Geometry;
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	float4 CustomVSToPS[CUSTOM_VERTEX_INTERPOLATORS_COUNT] : TEXCOORD9;
+#endif
+#if USE_TESSELLATION
+    float TessellationMultiplier : TESS;
+#endif
+};
+
+// Interpolants passed to the pixel shader
+struct PixelInput
+{
+	float4 Position : SV_Position;
+	GeometryData Geometry;
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	float4 CustomVSToPS[CUSTOM_VERTEX_INTERPOLATORS_COUNT] : TEXCOORD9;
+#endif
+	bool IsFrontFace : SV_IsFrontFace;
+};
+
+// Material properties generation input
+struct MaterialInput
+{
+	float3 WorldPosition;
+	float TwoSidedSign;
+	float2 TexCoord;
+#if USE_VERTEX_COLOR
+	half4 VertexColor;
+#endif
+	float3x3 TBN;
+	float4 SvPosition;
+	float3 PreSkinnedPosition;
+	float3 PreSkinnedNormal;
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	float4 CustomVSToPS[CUSTOM_VERTEX_INTERPOLATORS_COUNT];
+#endif
+};
+
+// Extracts geometry data to the material input
+MaterialInput GetGeometryMaterialInput(GeometryData geometry)
+{
+	MaterialInput output = (MaterialInput)0;
+	output.WorldPosition = geometry.WorldPosition;
+	output.TexCoord = geometry.TexCoord;
+#if USE_VERTEX_COLOR
+	output.VertexColor = geometry.VertexColor;
+#endif
+	output.TBN = CalcTangentBasis(geometry.WorldNormal, geometry.WorldTangent);
+	return output;
+}
+
+#if USE_TESSELLATION
+
+// Interpolates the geometry positions data only (used by the tessallation when generating vertices)
+#define InterpolateGeometryPositions(output, p0, w0, p1, w1, p2, w2, offset) output.WorldPosition = p0.WorldPosition * w0 + p1.WorldPosition * w1 + p2.WorldPosition * w2 + offset
+
+// Offsets the geometry positions data only (used by the tessallation when generating vertices)
+#define OffsetGeometryPositions(geometry, offset) geometry.WorldPosition += offset
+
+// Applies the Phong tessallation to the geometry positions (used by the tessallation when doing Phong tess)
+#define ApplyGeometryPositionsPhongTess(geometry, p0, p1, p2, U, V, W) \
+	float3 posProjectedU = TessalationProjectOntoPlane(p0.WorldNormal, p0.WorldPosition, geometry.WorldPosition); \
+	float3 posProjectedV = TessalationProjectOntoPlane(p1.WorldNormal, p1.WorldPosition, geometry.WorldPosition); \
+	float3 posProjectedW = TessalationProjectOntoPlane(p2.WorldNormal, p2.WorldPosition, geometry.WorldPosition); \
+	geometry.WorldPosition = U * posProjectedU + V * posProjectedV + W * posProjectedW
+
+// Interpolates the geometry data except positions (used by the tessallation when generating vertices)
+GeometryData InterpolateGeometry(GeometryData p0, float w0, GeometryData p1, float w1, GeometryData p2, float w2)
+{
+	GeometryData output = (GeometryData)0;
+	output.TexCoord = p0.TexCoord * w0 + p1.TexCoord * w1 + p2.TexCoord * w2;
+#if USE_VERTEX_COLOR
+	output.VertexColor = p0.VertexColor * w0 + p1.VertexColor * w1 + p2.VertexColor * w2;
+#endif
+	output.WorldNormal = p0.WorldNormal * w0 + p1.WorldNormal * w1 + p2.WorldNormal * w2;
+	output.WorldNormal = normalize(output.WorldNormal);
+	output.WorldTangent = p0.WorldTangent * w0 + p1.WorldTangent * w1 + p2.WorldTangent * w2;
+	output.WorldTangent.xyz = normalize(output.WorldTangent.xyz);
+	return output;
+}
+
+#endif
+
+MaterialInput GetMaterialInput(PixelInput input)
+{
+	MaterialInput output = GetGeometryMaterialInput(input.Geometry);
+	output.TwoSidedSign = WorldDeterminantSign * (input.IsFrontFace ? 1.0 : -1.0);
+	output.SvPosition = input.Position;
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	output.CustomVSToPS = input.CustomVSToPS;
+#endif
+	return output;
+}
+
+// Removes the scale vector from the local to world transformation matrix
+float3x3 RemoveScaleFromLocalToWorld(float3x3 localToWorld)
+{
+	// Extract per axis scales from localToWorld transform
+	float scaleX = length(localToWorld[0]);
+	float scaleY = length(localToWorld[1]);
+	float scaleZ = length(localToWorld[2]);
+	float3 invScale = float3(
+		scaleX > 0.00001f ? 1.0f / scaleX : 0.0f,
+		scaleY > 0.00001f ? 1.0f / scaleY : 0.0f,
+		scaleZ > 0.00001f ? 1.0f / scaleZ : 0.0f);
+	localToWorld[0] *= invScale.x;
+	localToWorld[1] *= invScale.y;
+	localToWorld[2] *= invScale.z;
+	return localToWorld;
+}
+
+// Transforms a vector from tangent space to world space
+float3 TransformTangentVectorToWorld(MaterialInput input, float3 tangentVector)
+{
+	return mul(tangentVector, input.TBN);
+}
+
+// Transforms a vector from world space to tangent space
+float3 TransformWorldVectorToTangent(MaterialInput input, float3 worldVector)
+{
+	return mul(input.TBN, worldVector);
+}
+
+// Transforms a vector from world space to view space
+float3 TransformWorldVectorToView(MaterialInput input, float3 worldVector)
+{
+	return mul(worldVector, (float3x3)ViewMatrix);
+}
+
+// Transforms a vector from view space to world space
+float3 TransformViewVectorToWorld(MaterialInput input, float3 viewVector)
+{
+	return mul((float3x3)ViewMatrix, viewVector);
+}
+
+// Transforms a vector from local space to world space
+float3 TransformLocalVectorToWorld(MaterialInput input, float3 localVector)
+{
+	float3x3 localToWorld = (float3x3)WorldMatrix;
+	//localToWorld = RemoveScaleFromLocalToWorld(localToWorld);
+	return mul(localVector, localToWorld);
+}
+
+// Transforms a vector from local space to world space
+float3 TransformWorldVectorToLocal(MaterialInput input, float3 worldVector)
+{
+	float3x3 localToWorld = (float3x3)WorldMatrix;
+	//localToWorld = RemoveScaleFromLocalToWorld(localToWorld);
+	return mul(localToWorld, worldVector);
+}
+
+// Gets the current object position
+float3 GetObjectPosition(MaterialInput input)
+{
+	return WorldMatrix[3].xyz;
+}
+
+// Gets the current object size
+float3 GetObjectSize(MaterialInput input)
+{
+	float4x4 world = WorldMatrix;
+	return GeometrySize * float3(world._m00, world._m11, world._m22);
+}
+
+// Get the current object random value
+float GetPerInstanceRandom(MaterialInput input)
+{
+	return PerInstanceRandom;
+}
+
+// Get the current object LOD transition dither factor
+float GetLODDitherFactor(MaterialInput input)
+{
+	return 0;
+}
+
+// Gets the interpolated vertex color (in linear space)
+float4 GetVertexColor(MaterialInput input)
+{
+#if USE_VERTEX_COLOR
+	return input.VertexColor;
+#else
+	return 1;
+#endif
+}
+
+float3 SampleLightmap(Material material, MaterialInput materialInput)
+{
+	return 0;
+}
+
+@8
+
+// Get material properties function (for vertex shader)
+Material GetMaterialVS(MaterialInput input)
+{
+@5
+}
+
+// Get material properties function (for domain shader)
+Material GetMaterialDS(MaterialInput input)
+{
+@6
+}
+
+// Get material properties function (for pixel shader)
+Material GetMaterialPS(MaterialInput input)
+{
+@4
+}
+
+// Calculates the transform matrix from mesh tangent space to local space
+float3x3 CalcTangentToLocal(ModelInput input)
+{
+	float bitangentSign = input.Tangent.w ? -1.0f : +1.0f;
+	float3 normal = input.Normal.xyz * 2.0 - 1.0;
+	float3 tangent = input.Tangent.xyz * 2.0 - 1.0;
+	float3 bitangent = cross(normal, tangent) * bitangentSign;
+	return float3x3(tangent, bitangent, normal);
+}
+
+// Vertex Shader function for GBuffer Pass and Depth Pass (with full vertex data)
+META_VS(true, FEATURE_LEVEL_ES2)
+META_VS_IN_ELEMENT(POSITION, 0, R32G32B32_FLOAT,   0, 0,     PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(TEXCOORD, 0, R16G16_FLOAT,      1, 0,     PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(NORMAL,   0, R10G10B10A2_UNORM, 1, ALIGN, PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(TANGENT,  0, R10G10B10A2_UNORM, 1, ALIGN, PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(TEXCOORD, 1, R16G16_FLOAT,      1, ALIGN, PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(COLOR,    0, R8G8B8A8_UNORM,    2, 0,     PER_VERTEX, 0, USE_VERTEX_COLOR)
+VertexOutput VS_SplineModel(ModelInput input)
+{
+	VertexOutput output;
+
+	// Apply local transformation of the geometry before deformation
+	float3 position = mul(float4(input.Position, 1), LocalMatrix).xyz;
+	float4x4 world = LocalMatrix;
+
+	// Apply spline curve deformation
+	float splineAlpha = saturate((position.z - MeshMinZ) / (MeshMaxZ - MeshMinZ));
+	int splineIndex = (int)((Segment + splineAlpha) * ChunksPerSegment);
+	position.z = splineAlpha;
+	float3x4 splineMatrix = float3x4(SplineDeformation[splineIndex * 3], SplineDeformation[splineIndex * 3 + 1], SplineDeformation[splineIndex * 3 + 2]);
+	position = mul(splineMatrix, float4(position, 1));
+	float4x3 splineMatrixT = transpose(splineMatrix);
+	world = mul(world, float4x4(float4(splineMatrixT[0], 0), float4(splineMatrixT[1], 0), float4(splineMatrixT[2], 0), float4(splineMatrixT[3], 1)));
+
+	// Compute world space vertex position
+	output.Geometry.WorldPosition = mul(float4(position, 1), WorldMatrix).xyz;
+	world = mul(world, WorldMatrix);
+
+	// Compute clip space position
+	output.Position = mul(float4(output.Geometry.WorldPosition, 1), ViewProjectionMatrix);
+
+	// Pass vertex attributes
+	output.Geometry.TexCoord = input.TexCoord;
+#if USE_VERTEX_COLOR
+	output.Geometry.VertexColor = input.Color;
+#endif
+
+	// Calculate tanget space to world space transformation matrix for unit vectors
+	float3x3 tangentToLocal = CalcTangentToLocal(input);
+	float3x3 localToWorld = RemoveScaleFromLocalToWorld((float3x3)world);
+	float3x3 tangentToWorld = mul(tangentToLocal, localToWorld); 
+	output.Geometry.WorldNormal = tangentToWorld[2];
+	output.Geometry.WorldTangent.xyz = tangentToWorld[0];
+	output.Geometry.WorldTangent.w = input.Tangent.w ? -1.0f : +1.0f;
+
+	// Get material input params if need to evaluate any material property
+#if USE_POSITION_OFFSET || USE_TESSELLATION || USE_CUSTOM_VERTEX_INTERPOLATORS
+	MaterialInput materialInput = GetGeometryMaterialInput(output.Geometry);
+	materialInput.TwoSidedSign = WorldDeterminantSign;
+	materialInput.SvPosition = output.Position;
+	materialInput.PreSkinnedPosition = input.Position.xyz;
+	materialInput.PreSkinnedNormal = tangentToLocal[2].xyz;
+	Material material = GetMaterialVS(materialInput);
+#endif
+
+	// Apply world position offset per-vertex
+#if USE_POSITION_OFFSET
+	output.Geometry.WorldPosition += material.PositionOffset;
+	output.Position = mul(float4(output.Geometry.WorldPosition, 1), ViewProjectionMatrix);
+#endif
+
+	// Get tessalation multiplier (per vertex)
+#if USE_TESSELLATION
+    output.TessellationMultiplier = material.TessellationMultiplier;
+#endif
+
+	// Copy interpolants for other shader stages
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	output.CustomVSToPS = material.CustomVSToPS;
+#endif
+
+	return output;
+}
+
+#if USE_DITHERED_LOD_TRANSITION
+
+void ClipLODTransition(PixelInput input)
+{
+}
+
+#endif
+
+// Pixel Shader function for Depth Pass
+META_PS(true, FEATURE_LEVEL_ES2)
+void PS_Depth(PixelInput input)
+{
+#if MATERIAL_MASKED || MATERIAL_BLEND != MATERIAL_BLEND_OPAQUE 
+	// Get material parameters
+	MaterialInput materialInput = GetMaterialInput(input);
+	Material material = GetMaterialPS(materialInput);
+
+	// Perform per pixel clipping
+#if MATERIAL_MASKED
+	clip(material.Mask - MATERIAL_MASK_THRESHOLD);
+#endif
+#if MATERIAL_BLEND != MATERIAL_BLEND_OPAQUE
+	clip(material.Opacity - MATERIAL_OPACITY_THRESHOLD);
+#endif
+#endif
+}
+
+@9
@@ -0,0 +1,84 @@
+// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
+
+@0// Deferred Shading: Defines
+@1// Deferred Shading: Includes
+@2// Deferred Shading: Constants
+@3// Deferred Shading: Resources
+@4// Deferred Shading: Utilities
+@5// Deferred Shading: Shaders
+
+// Pixel Shader function for GBuffer Pass
+META_PS(true, FEATURE_LEVEL_ES2)
+META_PERMUTATION_1(USE_LIGHTMAP=0)
+META_PERMUTATION_1(USE_LIGHTMAP=1)
+void PS_GBuffer(
+		in PixelInput input
+		,out float4 Light : SV_Target0
+#if MATERIAL_BLEND == MATERIAL_BLEND_OPAQUE
+		// GBuffer
+		,out float4 RT0   : SV_Target1
+		,out float4 RT1   : SV_Target2
+		,out float4 RT2   : SV_Target3
+#if USE_GBUFFER_CUSTOM_DATA
+		,out float4 RT3   : SV_Target4
+#endif
+#endif
+	)
+{
+	Light = 0;
+	
+#if USE_DITHERED_LOD_TRANSITION
+	// LOD masking
+	ClipLODTransition(input);
+#endif
+
+	// Get material parameters
+	MaterialInput materialInput = GetMaterialInput(input);
+	Material material = GetMaterialPS(materialInput);
+
+	// Masking
+#if MATERIAL_MASKED
+	clip(material.Mask - MATERIAL_MASK_THRESHOLD);
+#endif
+	
+#if USE_LIGHTMAP
+	float3 diffuseColor = GetDiffuseColor(material.Color, material.Metalness);
+	float3 specularColor = GetSpecularColor(material.Color, material.Specular, material.Metalness);
+
+	// Sample lightmap
+	float3 diffuseIndirectLighting = SampleLightmap(material, materialInput);
+
+	// Apply static indirect light
+	Light.rgb = diffuseColor * diffuseIndirectLighting * AOMultiBounce(material.AO, diffuseColor);
+#endif
+
+#if MATERIAL_BLEND == MATERIAL_BLEND_OPAQUE
+
+	// Pack material properties to GBuffer
+	RT0 = float4(material.Color, material.AO);
+	RT1 = float4(material.WorldNormal * 0.5 + 0.5, MATERIAL_SHADING_MODEL * (1.0 / 3.0));
+	RT2 = float4(material.Roughness, material.Metalness, material.Specular, 0);
+
+	// Custom data
+#if USE_GBUFFER_CUSTOM_DATA
+#if MATERIAL_SHADING_MODEL == SHADING_MODEL_SUBSURFACE
+	RT3 = float4(material.SubsurfaceColor, material.Opacity);
+#elif MATERIAL_SHADING_MODEL == SHADING_MODEL_FOLIAGE
+	RT3 = float4(material.SubsurfaceColor, material.Opacity);
+#else
+	RT3 = float4(0, 0, 0, 0);
+#endif
+#endif
+
+	// Add light emission
+#if USE_EMISSIVE
+	Light.rgb += material.Emissive;
+#endif
+
+#else
+
+	// Handle blending as faked forward pass (use Light buffer and skip GBuffer modification)
+	Light = float4(material.Emissive, material.Opacity);
+
+#endif
+}
@@ -0,0 +1,50 @@
+// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
+
+@0// Distortion: Defines
+@1// Distortion: Includes
+@2// Distortion: Constants
+@3// Distortion: Resources
+@4// Distortion: Utilities
+@5// Distortion: Shaders
+#if USE_DISTORTION
+
+// Pixel Shader function for Distortion Pass
+META_PS(USE_DISTORTION, FEATURE_LEVEL_ES2)
+float4 PS_Distortion(PixelInput input) : SV_Target0
+{
+#if USE_DITHERED_LOD_TRANSITION
+	// LOD masking
+	ClipLODTransition(input);
+#endif
+
+	// Get material parameters
+	MaterialInput materialInput = GetMaterialInput(input);
+	Material material = GetMaterialPS(materialInput);
+
+	// Masking
+#if MATERIAL_MASKED
+	clip(material.Mask - MATERIAL_MASK_THRESHOLD);
+#endif
+
+	float3 viewNormal = normalize(TransformWorldVectorToView(materialInput, material.WorldNormal));
+	float airIOR = 1.0f;
+#if USE_PIXEL_NORMAL_OFFSET_REFRACTION
+	float3 viewVertexNormal = TransformWorldVectorToView(materialInput, TransformTangentVectorToWorld(materialInput, float3(0, 0, 1)));
+	float2 distortion = (viewVertexNormal.xy - viewNormal.xy) * (material.Refraction - airIOR);
+#else
+	float2 distortion = viewNormal.xy * (material.Refraction - airIOR);
+#endif
+
+	// Clip if the distortion distance (squared) is too small to be noticed
+	clip(dot(distortion, distortion) - 0.00001);
+
+	// Scale up for better precision in low/subtle refractions at the expense of artefacts at higher refraction
+	distortion *= 4.0f;
+	
+	// Use separate storage for positive and negative offsets
+	float2 addOffset = max(distortion, 0);
+	float2 subOffset = abs(min(distortion, 0));
+	return float4(addOffset.x, addOffset.y, subOffset.x, subOffset.y);
+}
+
+#endif
@@ -0,0 +1,124 @@
+// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
+
+@0// Forward Shading: Defines
+#define MAX_LOCAL_LIGHTS 4
+@1// Forward Shading: Includes
+#include "./Flax/LightingCommon.hlsl"
+#if USE_REFLECTIONS
+#include "./Flax/ReflectionsCommon.hlsl"
+#endif
+#include "./Flax/Lighting.hlsl"
+#include "./Flax/ShadowsSampling.hlsl"
+#include "./Flax/ExponentialHeightFog.hlsl"
+@2// Forward Shading: Constants
+LightData DirectionalLight;
+LightShadowData DirectionalLightShadow;
+LightData SkyLight;
+ProbeData EnvironmentProbe;
+ExponentialHeightFogData ExponentialHeightFog;
+float3 Dummy2;
+uint LocalLightsCount;
+LightData LocalLights[MAX_LOCAL_LIGHTS];
+@3// Forward Shading: Resources
+TextureCube EnvProbe : register(t__SRV__);
+TextureCube SkyLightTexture : register(t__SRV__);
+Texture2DArray DirectionalLightShadowMap : register(t__SRV__);
+@4// Forward Shading: Utilities
+DECLARE_LIGHTSHADOWDATA_ACCESS(DirectionalLightShadow);
+@5// Forward Shading: Shaders
+
+// Pixel Shader function for Forward Pass
+META_PS(USE_FORWARD, FEATURE_LEVEL_ES2)
+float4 PS_Forward(PixelInput input) : SV_Target0
+{
+	float4 output = 0;
+
+#if USE_DITHERED_LOD_TRANSITION
+	// LOD masking
+	ClipLODTransition(input);
+#endif
+
+	// Get material parameters
+	MaterialInput materialInput = GetMaterialInput(input);
+	Material material = GetMaterialPS(materialInput);
+
+	// Masking
+#if MATERIAL_MASKED
+	clip(material.Mask - MATERIAL_MASK_THRESHOLD);
+#endif
+
+	// Add emissive light
+	output = float4(material.Emissive, material.Opacity);
+
+#if MATERIAL_SHADING_MODEL != SHADING_MODEL_UNLIT
+
+	// Setup GBuffer data as proxy for lighting
+	GBufferSample gBuffer;
+	gBuffer.Normal = material.WorldNormal;
+	gBuffer.Roughness = material.Roughness;
+	gBuffer.Metalness = material.Metalness;
+	gBuffer.Color = material.Color;
+	gBuffer.Specular = material.Specular;
+	gBuffer.AO = material.AO;
+	gBuffer.ViewPos = mul(float4(materialInput.WorldPosition, 1), ViewMatrix).xyz;
+#if MATERIAL_SHADING_MODEL == SHADING_MODEL_SUBSURFACE
+	gBuffer.CustomData = float4(material.SubsurfaceColor, material.Opacity);
+#elif MATERIAL_SHADING_MODEL == SHADING_MODEL_FOLIAGE
+	gBuffer.CustomData = float4(material.SubsurfaceColor, material.Opacity);
+#else
+	gBuffer.CustomData = float4(0, 0, 0, 0);
+#endif
+	gBuffer.WorldPos = materialInput.WorldPosition;
+	gBuffer.ShadingModel = MATERIAL_SHADING_MODEL;
+
+	// Calculate lighting from a single directional light
+	float4 shadowMask = 1.0f;
+	if (DirectionalLight.CastShadows > 0)
+	{
+		LightShadowData directionalLightShadowData = GetDirectionalLightShadowData();
+		shadowMask.r = SampleShadow(DirectionalLight, directionalLightShadowData, DirectionalLightShadowMap, gBuffer, shadowMask.g);
+	}
+	float4 light = GetLighting(ViewPos, DirectionalLight, gBuffer, shadowMask, false, false);
+
+	// Calculate lighting from sky light
+	light += GetSkyLightLighting(SkyLight, gBuffer, SkyLightTexture);
+
+	// Calculate lighting from local lights
+	LOOP
+	for (uint localLightIndex = 0; localLightIndex < LocalLightsCount; localLightIndex++)
+	{
+		const LightData localLight = LocalLights[localLightIndex];
+		bool isSpotLight = localLight.SpotAngles.x > -2.0f;
+		shadowMask = 1.0f;
+		light += GetLighting(ViewPos, localLight, gBuffer, shadowMask, true, isSpotLight);
+	}
+
+#if USE_REFLECTIONS
+	// Calculate reflections
+	light.rgb += GetEnvProbeLighting(ViewPos, EnvProbe, EnvironmentProbe, gBuffer) * light.a;	
+#endif
+
+	// Add lighting (apply ambient occlusion)
+	output.rgb += light.rgb * gBuffer.AO;
+
+#if USE_FOG
+	// Calculate exponential height fog
+	float4 fog = GetExponentialHeightFog(ExponentialHeightFog, materialInput.WorldPosition, ViewPos, 0);
+
+	// Apply fog to the output color
+#if MATERIAL_BLEND == MATERIAL_BLEND_OPAQUE
+	output = float4(output.rgb * fog.a + fog.rgb, output.a);
+#elif MATERIAL_BLEND == MATERIAL_BLEND_TRANSPARENT
+	output = float4(output.rgb * fog.a + fog.rgb, output.a);
+#elif MATERIAL_BLEND == MATERIAL_BLEND_ADDITIVE
+	output = float4(output.rgb * fog.a + fog.rgb, output.a * fog.a);
+#elif MATERIAL_BLEND == MATERIAL_BLEND_MULTIPLY
+	output = float4(lerp(float3(1, 1, 1), output.rgb, fog.aaa * fog.aaa), output.a);
+#endif
+
+#endif
+	
+#endif
+
+	return output;
+}
@@ -0,0 +1,54 @@
+// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
+
+@0// Lightmap: Defines
+#define CAN_USE_LIGHTMAP 1
+@1// Lightmap: Includes
+@2// Lightmap: Constants
+float4 LightmapArea;
+@3// Lightmap: Resources
+#if USE_LIGHTMAP
+// Irradiance and directionality prebaked lightmaps
+Texture2D Lightmap0 : register(t__SRV__);
+Texture2D Lightmap1 : register(t__SRV__);
+Texture2D Lightmap2 : register(t__SRV__);
+#endif
+@4// Lightmap: Utilities
+#if USE_LIGHTMAP
+
+// Evaluates the H-Basis coefficients in the tangent space normal direction
+float3 GetHBasisIrradiance(float3 n, float3 h0, float3 h1, float3 h2, float3 h3)
+{
+	// Band 0
+	float3 color = h0 * (1.0f / sqrt(2.0f * PI));
+
+	// Band 1
+	color += h1 * -sqrt(1.5f / PI) * n.y;
+	color += h2 *  sqrt(1.5f / PI) * (2 * n.z - 1.0f);
+	color += h3 * -sqrt(1.5f / PI) * n.x;
+
+	return color;
+}
+
+float3 SampleLightmap(Material material, MaterialInput materialInput)
+{
+	// Sample lightmaps
+	float4 lightmap0 = Lightmap0.Sample(SamplerLinearClamp, materialInput.LightmapUV);
+	float4 lightmap1 = Lightmap1.Sample(SamplerLinearClamp, materialInput.LightmapUV);
+	float4 lightmap2 = Lightmap2.Sample(SamplerLinearClamp, materialInput.LightmapUV);
+
+	// Unpack H-basis
+	float3 h0 = float3(lightmap0.x, lightmap1.x, lightmap2.x);
+	float3 h1 = float3(lightmap0.y, lightmap1.y, lightmap2.y);
+	float3 h2 = float3(lightmap0.z, lightmap1.z, lightmap2.z);
+	float3 h3 = float3(lightmap0.w, lightmap1.w, lightmap2.w);
+
+	// Sample baked diffuse irradiance from the H-basis coefficients
+	float3 normal = material.TangentNormal;
+#if MATERIAL_SHADING_MODEL == SHADING_MODEL_FOLIAGE
+	normal *= material.TangentNormal;
+#endif
+	return GetHBasisIrradiance(normal, h0, h1, h2, h3) / PI;
+}
+
+#endif
+@5// Lightmap: Shaders
@@ -0,0 +1,44 @@
+// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
+
+@0// Motion Vectors: Defines
+@1// Motion Vectors: Includes
+@2// Motion Vectors: Constants
+@3// Motion Vectors: Resources
+@4// Motion Vectors: Utilities
+@5// Motion Vectors: Shaders
+
+// Pixel Shader function for Motion Vectors Pass
+META_PS(true, FEATURE_LEVEL_ES2)
+float4 PS_MotionVectors(PixelInput input) : SV_Target0
+{
+#if USE_DITHERED_LOD_TRANSITION
+	// LOD masking
+	ClipLODTransition(input);
+#endif
+
+#if MATERIAL_MASKED
+	// Perform per pixel clipping if material requries it
+	MaterialInput materialInput = GetMaterialInput(input);
+	Material material = GetMaterialPS(materialInput);
+	clip(material.Mask - MATERIAL_MASK_THRESHOLD);
+#endif
+
+	// Calculate this and previosu frame pixel locations in clip space
+	float4 prevClipPos = mul(float4(input.Geometry.PrevWorldPosition, 1), PrevViewProjectionMatrix);
+	float4 curClipPos = mul(float4(input.Geometry.WorldPosition, 1), ViewProjectionMatrix);
+	float2 prevHPos = prevClipPos.xy / prevClipPos.w;
+	float2 curHPos = curClipPos.xy / curClipPos.w;
+
+	// Revert temporal jitter offset
+	prevHPos -= TemporalAAJitter.zw;
+	curHPos -= TemporalAAJitter.xy;
+
+	// Clip Space -> UV Space
+	float2 vPosPrev = prevHPos.xy * 0.5f + 0.5f;
+	float2 vPosCur = curHPos.xy * 0.5f + 0.5f;
+	vPosPrev.y = 1.0 - vPosPrev.y;
+	vPosCur.y = 1.0 - vPosCur.y;
+
+	// Calculate per-pixel motion vector
+	return float4(vPosCur - vPosPrev, 0, 1);
+}
@@ -0,0 +1,184 @@
+// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
+
+@0// Tessellation: Defines
+#define TessalationProjectOntoPlane(planeNormal, planePosition, pointToProject) pointToProject - dot(pointToProject - planePosition, planeNormal) * planeNormal
+@1// Tessellation: Includes
+@2// Tessellation: Constants
+@3// Tessellation: Resources
+@4// Tessellation: Utilities
+@5// Tessellation: Shaders
+#if USE_TESSELLATION
+
+// Interpolants passed from the hull shader to the domain shader
+struct TessalationHSToDS
+{
+	float4 Position : SV_Position;
+	GeometryData Geometry;
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	float4 CustomVSToPS[CUSTOM_VERTEX_INTERPOLATORS_COUNT] : TEXCOORD9;
+#endif
+	float TessellationMultiplier : TESS;
+};
+
+// Interpolants passed from the domain shader and to the pixel shader
+struct TessalationDSToPS
+{
+	float4 Position : SV_Position;
+	GeometryData Geometry;
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	float4 CustomVSToPS[CUSTOM_VERTEX_INTERPOLATORS_COUNT] : TEXCOORD9;
+#endif
+};
+
+MaterialInput GetMaterialInput(TessalationDSToPS input)
+{
+	MaterialInput output = GetGeometryMaterialInput(input.Geometry);
+	output.SvPosition = input.Position;
+	output.TwoSidedSign = WorldDeterminantSign;
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	output.CustomVSToPS = input.CustomVSToPS;
+#endif
+	return output;
+}
+
+struct TessalationPatch
+{
+	float EdgeTessFactor[3] : SV_TessFactor;
+	float InsideTessFactor : SV_InsideTessFactor;
+#if MATERIAL_TESSELLATION == MATERIAL_TESSELLATION_PN
+	float3 B210 : POSITION4;
+	float3 B120 : POSITION5;
+	float3 B021 : POSITION6;
+	float3 B012 : POSITION7;
+	float3 B102 : POSITION8;
+	float3 B201 : POSITION9;
+	float3 B111 : CENTER;
+#endif
+};
+
+TessalationPatch HS_PatchConstant(InputPatch<VertexOutput, 3> input)
+{
+	TessalationPatch output;
+
+	// Average tess factors along edges, and pick an edge tess factor for the interior tessellation
+	float4 tessellationMultipliers;
+	tessellationMultipliers.x = 0.5f * (input[1].TessellationMultiplier + input[2].TessellationMultiplier);
+	tessellationMultipliers.y = 0.5f * (input[2].TessellationMultiplier + input[0].TessellationMultiplier);
+	tessellationMultipliers.z = 0.5f * (input[0].TessellationMultiplier + input[1].TessellationMultiplier);
+	tessellationMultipliers.w = 0.333f * (input[0].TessellationMultiplier + input[1].TessellationMultiplier + input[2].TessellationMultiplier);
+	tessellationMultipliers = clamp(tessellationMultipliers, 1, MAX_TESSELLATION_FACTOR);
+
+	output.EdgeTessFactor[0] = tessellationMultipliers.x; // 1->2 edge
+	output.EdgeTessFactor[1] = tessellationMultipliers.y; // 2->0 edge
+	output.EdgeTessFactor[2] = tessellationMultipliers.z; // 0->1 edge
+	output.InsideTessFactor  = tessellationMultipliers.w;
+
+#if MATERIAL_TESSELLATION == MATERIAL_TESSELLATION_PN
+	// Calculate PN Triangle control points
+	// Reference: [Vlachos 2001]
+	float3 p1 = input[0].Geometry.WorldPosition;
+	float3 p2 = input[1].Geometry.WorldPosition;
+	float3 p3 = input[2].Geometry.WorldPosition;
+	float3 n1 = input[0].Geometry.WorldNormal;
+	float3 n2 = input[1].Geometry.WorldNormal;
+	float3 n3 = input[2].Geometry.WorldNormal;
+	output.B210 = (2.0f * p1 + p2 - dot((p2 - p1), n1) * n1) / 3.0f;
+	output.B120 = (2.0f * p2 + p1 - dot((p1 - p2), n2) * n2) / 3.0f;
+	output.B021 = (2.0f * p2 + p3 - dot((p3 - p2), n2) * n2) / 3.0f;
+	output.B012 = (2.0f * p3 + p2 - dot((p2 - p3), n3) * n3) / 3.0f;
+	output.B102 = (2.0f * p3 + p1 - dot((p1 - p3), n3) * n3) / 3.0f;
+	output.B201 = (2.0f * p1 + p3 - dot((p3 - p1), n1) * n1) / 3.0f;
+	float3 e = (output.B210 + output.B120 + output.B021 + output.B012 + output.B102 + output.B201) / 6.0f;
+	float3 v = (p1 + p2 + p3) / 3.0f;
+	output.B111 = e + ((e - v) / 2.0f);
+#endif
+
+	return output;
+}
+
+META_HS(USE_TESSELLATION, FEATURE_LEVEL_SM5)
+META_HS_PATCH(TESSELLATION_IN_CONTROL_POINTS)
+[domain("tri")]
+[partitioning("fractional_odd")]
+[outputtopology("triangle_cw")]
+[maxtessfactor(MAX_TESSELLATION_FACTOR)]
+[outputcontrolpoints(3)]
+[patchconstantfunc("HS_PatchConstant")]
+TessalationHSToDS HS(InputPatch<VertexOutput, TESSELLATION_IN_CONTROL_POINTS> input, uint ControlPointID : SV_OutputControlPointID)
+{
+	TessalationHSToDS output;
+
+	// Pass through shader
+#define COPY(thing) output.thing = input[ControlPointID].thing;
+	COPY(Position);
+	COPY(Geometry);
+	COPY(TessellationMultiplier);
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	COPY(CustomVSToPS);
+#endif
+#undef COPY
+
+	return output;
+}
+
+META_DS(USE_TESSELLATION, FEATURE_LEVEL_SM5)
+[domain("tri")]
+TessalationDSToPS DS(TessalationPatch constantData, float3 barycentricCoords : SV_DomainLocation, const OutputPatch<TessalationHSToDS, 3> input)
+{
+	TessalationDSToPS output;
+
+	// Get the barycentric coords
+	float U = barycentricCoords.x;
+	float V = barycentricCoords.y;
+	float W = barycentricCoords.z;
+
+	// Interpolate patch attributes to generated vertices
+	output.Geometry = InterpolateGeometry(input[0].Geometry, U, input[1].Geometry, V, input[2].Geometry, W);
+#define INTERPOLATE(thing) output.thing = U * input[0].thing + V * input[1].thing + W * input[2].thing
+	INTERPOLATE(Position);
+#if MATERIAL_TESSELLATION == MATERIAL_TESSELLATION_PN
+	// Interpolate using barycentric coordinates and PN Triangle control points
+	float UU = U * U;
+	float VV = V * V;
+	float WW = W * W;
+	float UU3 = UU * 3.0f;
+	float VV3 = VV * 3.0f;
+	float WW3 = WW * 3.0f;
+	float3 offset = 
+		constantData.B210 * UU3 * V +
+		constantData.B120 * VV3 * U +
+		constantData.B021 * VV3 * W +
+		constantData.B012 * WW3 * V +
+		constantData.B102 * WW3 * U +
+		constantData.B201 * UU3 * W +
+		constantData.B111 * 6.0f * W * U * V;
+	InterpolateGeometryPositions(output.Geometry, input[0].Geometry, UU * U, input[1].Geometry, VV * V, input[2].Geometry, WW * W, offset);
+#else
+	InterpolateGeometryPositions(output.Geometry, input[0].Geometry, U, input[1].Geometry, V, input[2].Geometry, W, float3(0, 0, 0));
+#endif
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	UNROLL
+	for (int i = 0; i < CUSTOM_VERTEX_INTERPOLATORS_COUNT; i++)
+		INTERPOLATE(CustomVSToPS[i]);
+#endif
+#undef INTERPOLATE
+
+#if MATERIAL_TESSELLATION == MATERIAL_TESSELLATION_PHONG
+	// Orthogonal projection in the tangent planes with interpolation
+	ApplyGeometryPositionsPhongTess(output.Geometry, input[0].Geometry, input[1].Geometry, input[2].Geometry, U, V, W);
+#endif
+
+	// Perform displacement mapping
+#if USE_DISPLACEMENT
+	MaterialInput materialInput = GetMaterialInput(output);
+	Material material = GetMaterialDS(materialInput);
+	OffsetGeometryPositions(output.Geometry, material.WorldDisplacement);
+#endif
+
+	// Recalculate the clip space position
+	output.Position = mul(float4(output.Geometry.WorldPosition, 1), ViewProjectionMatrix);
+
+	return output;
+}
+
+#endif
@@ -3,7 +3,6 @@

 #define MATERIAL 1
@3
-
 #include "./Flax/Common.hlsl"
 #include "./Flax/MaterialCommon.hlsl"
 #include "./Flax/GBufferCommon.hlsl"
@@ -22,7 +21,7 @@ float4 ViewInfo;
 float4 ScreenSize;
@1META_CB_END

-// Material shader resources
+// Shader resources
@2
 // Interpolants passed from the vertex shader
 struct VertexOutput
@@ -185,6 +184,8 @@ float4 GetVertexColor(MaterialInput input)
 #endif
 }

+@8
+
 // Get material properties function (for vertex shader)
 Material GetMaterialVS(MaterialInput input)
 {
@@ -197,10 +198,6 @@ Material GetMaterialPS(MaterialInput input)
@4
 }

-// Programmatically set the line number after all the material inputs which have a variable number of line endings
-// This allows shader error line numbers after this point to be the same regardless of which material is being compiled
-#line 1000
-
 // Vertex Shader function for GUI materials rendering
 META_VS(true, FEATURE_LEVEL_ES2)
 META_VS_IN_ELEMENT(POSITION, 0, R32G32_FLOAT,       0, ALIGN, PER_VERTEX, 0, true)
@@ -258,3 +255,5 @@ float4 PS_GUI(PixelInput input) : SV_Target0

 	return float4(material.Emissive, material.Opacity);
 }
+
+@9
@@ -2,19 +2,13 @@
 // Version: @0

 #define MATERIAL 1
-#define MAX_LOCAL_LIGHTS 4
@3
+// Ribbons don't use sorted indices so overlap the segment distances buffer on the slot
+#define HAS_SORTED_INDICES (!defined(_VS_Ribbon))

 #include "./Flax/Common.hlsl"
 #include "./Flax/MaterialCommon.hlsl"
 #include "./Flax/GBufferCommon.hlsl"
-#include "./Flax/LightingCommon.hlsl"
-#if USE_REFLECTIONS
-#include "./Flax/ReflectionsCommon.hlsl"
-#endif
-#include "./Flax/Lighting.hlsl"
-#include "./Flax/ShadowsSampling.hlsl"
-#include "./Flax/ExponentialHeightFog.hlsl"
 #include "./Flax/Matrix.hlsl"
@7
 struct SpriteInput
@@ -55,44 +49,19 @@ uint RibbonSegmentCount;
 float4x4 WorldMatrixInverseTransposed;
@1META_CB_END

-// Secondary constantant buffer (for lighting)
-META_CB_BEGIN(1, LightingData)
-LightData DirectionalLight;
-LightShadowData DirectionalLightShadow;
-LightData SkyLight;
-ProbeData EnvironmentProbe;
-ExponentialHeightFogData ExponentialHeightFog;
-float3 Dummy1;
-uint LocalLightsCount;
-LightData LocalLights[MAX_LOCAL_LIGHTS];
-META_CB_END
-
-DECLARE_LIGHTSHADOWDATA_ACCESS(DirectionalLightShadow);
-
 // Particles attributes buffer
 ByteAddressBuffer ParticlesData : register(t0);

-// Ribbons don't use sorted indices so overlap the segment distances buffer on the slot
-#define HAS_SORTED_INDICES (!defined(_VS_Ribbon))
-
 #if HAS_SORTED_INDICES
-
 // Sorted particles indices
 Buffer<uint> SortedIndices : register(t1);
-
 #else
-
 // Ribbon particles segments distances buffer
 Buffer<float> SegmentDistances : register(t1);
-
 #endif

 // Shader resources
-TextureCube EnvProbe : register(t2);
-TextureCube SkyLightTexture : register(t3);
-Texture2DArray DirectionalLightShadowMap : register(t4);
@2
-
 // Interpolants passed from the vertex shader
 struct VertexOutput
 {
@@ -172,14 +141,11 @@ MaterialInput GetMaterialInput(PixelInput input)
 }

 // Gets the local to world transform matrix (supports instancing)
-float4x4 GetInstanceTransform(ModelInput input)
-{
-	return WorldMatrix;
-}
-float4x4 GetInstanceTransform(MaterialInput input)
-{
-	return WorldMatrix;
-}
+#if USE_INSTANCING
+#define GetInstanceTransform(input) float4x4(float4(input.InstanceTransform1.xyz, 0.0f), float4(input.InstanceTransform2.xyz, 0.0f), float4(input.InstanceTransform3.xyz, 0.0f), float4(input.InstanceOrigin.xyz, 1.0f))
+#else
+#define GetInstanceTransform(input) WorldMatrix;
+#endif

 // Removes the scale vector from the local to world transformation matrix (supports instancing)
 float3x3 RemoveScaleFromLocalToWorld(float3x3 localToWorld)
@@ -312,6 +278,8 @@ float3 TransformParticleVector(float3 input)
 	return mul(float4(input, 0.0f), WorldMatrixInverseTransposed).xyz;
 }

+@8
+
 // Get material properties function (for vertex shader)
 Material GetMaterialVS(MaterialInput input)
 {
@@ -330,10 +298,6 @@ Material GetMaterialPS(MaterialInput input)
@4
 }

-// Programmatically set the line number after all the material inputs which have a variable number of line endings
-// This allows shader error line numbers after this point to be the same regardless of which material is being compiled
-#line 1000
-
 // Calculates the transform matrix from mesh tangent space to local space
 half3x3 CalcTangentToLocal(ModelInput input)
 {
@@ -713,142 +677,9 @@ VertexOutput VS_Ribbon(uint vertexIndex : SV_VertexID)
 	return output;
 }

-// Pixel Shader function for Forward Pass
-META_PS(USE_FORWARD, FEATURE_LEVEL_ES2)
-float4 PS_Forward(PixelInput input) : SV_Target0
-{
-	float4 output = 0;
-
-	// Get material parameters
-	MaterialInput materialInput = GetMaterialInput(input);
-	Material material = GetMaterialPS(materialInput);
-
-	// Masking
-#if MATERIAL_MASKED
-	clip(material.Mask - MATERIAL_MASK_THRESHOLD);
-#endif
-
-	// Add emissive light
-	output = float4(material.Emissive, material.Opacity);
-
-#if MATERIAL_SHADING_MODEL != SHADING_MODEL_UNLIT
-
-	// Setup GBuffer data as proxy for lighting
-	GBufferSample gBuffer;
-	gBuffer.Normal = material.WorldNormal;
-	gBuffer.Roughness = material.Roughness;
-	gBuffer.Metalness = material.Metalness;
-	gBuffer.Color = material.Color;
-	gBuffer.Specular = material.Specular;
-	gBuffer.AO = material.AO;
-	gBuffer.ViewPos = mul(float4(materialInput.WorldPosition, 1), ViewMatrix).xyz;
-#if MATERIAL_SHADING_MODEL == SHADING_MODEL_SUBSURFACE
-	gBuffer.CustomData = float4(material.SubsurfaceColor, material.Opacity);
-#elif MATERIAL_SHADING_MODEL == SHADING_MODEL_FOLIAGE
-	gBuffer.CustomData = float4(material.SubsurfaceColor, material.Opacity);
-#else
-	gBuffer.CustomData = float4(0, 0, 0, 0);
-#endif
-	gBuffer.WorldPos = materialInput.WorldPosition;
-	gBuffer.ShadingModel = MATERIAL_SHADING_MODEL;
-
-	// Calculate lighting from a single directional light
-	float4 shadowMask = 1.0f;
-	if (DirectionalLight.CastShadows > 0)
-	{
-		LightShadowData directionalLightShadowData = GetDirectionalLightShadowData();
-		shadowMask.r = SampleShadow(DirectionalLight, directionalLightShadowData, DirectionalLightShadowMap, gBuffer, shadowMask.g);
-	}
-	float4 light = GetLighting(ViewPos, DirectionalLight, gBuffer, shadowMask, false, false);
-
-	// Calculate lighting from sky light
-	light += GetSkyLightLighting(SkyLight, gBuffer, SkyLightTexture);
-
-	// Calculate lighting from local lights
-	LOOP
-	for (uint localLightIndex = 0; localLightIndex < LocalLightsCount; localLightIndex++)
-	{
-		const LightData localLight = LocalLights[localLightIndex];
-		bool isSpotLight = localLight.SpotAngles.x > -2.0f;
-		shadowMask = 1.0f;
-		light += GetLighting(ViewPos, localLight, gBuffer, shadowMask, true, isSpotLight);
-	}
-
-#if USE_REFLECTIONS
-	// Calculate reflections
-	light.rgb += GetEnvProbeLighting(ViewPos, EnvProbe, EnvironmentProbe, gBuffer) * light.a;	
-#endif
-
-	// Add lighting (apply ambient occlusion)
-	output.rgb += light.rgb * gBuffer.AO;
-
-#if USE_FOG
-	// Calculate exponential height fog
-	float4 fog = GetExponentialHeightFog(ExponentialHeightFog, materialInput.WorldPosition, ViewPos, 0);
-
-	// Apply fog to the output color
-#if MATERIAL_BLEND == MATERIAL_BLEND_OPAQUE
-	output = float4(output.rgb * fog.a + fog.rgb, output.a);
-#elif MATERIAL_BLEND == MATERIAL_BLEND_TRANSPARENT
-	output = float4(output.rgb * fog.a + fog.rgb, output.a);
-#elif MATERIAL_BLEND == MATERIAL_BLEND_ADDITIVE
-	output = float4(output.rgb * fog.a + fog.rgb, output.a * fog.a);
-#elif MATERIAL_BLEND == MATERIAL_BLEND_MULTIPLY
-	output = float4(lerp(float3(1, 1, 1), output.rgb, fog.aaa * fog.aaa), output.a);
-#endif
-
-#endif
-
-#endif
-
-	return output;
-}
-
-#if USE_DISTORTION
-
-// Pixel Shader function for Distortion Pass
-META_PS(USE_DISTORTION, FEATURE_LEVEL_ES2)
-float4 PS_Distortion(PixelInput input) : SV_Target0
-{
-	// Get material parameters
-	MaterialInput materialInput = GetMaterialInput(input);
-	Material material = GetMaterialPS(materialInput);
-
-	// Masking
-#if MATERIAL_MASKED
-	clip(material.Mask - MATERIAL_MASK_THRESHOLD);
-#endif
-
-	float3 viewNormal = normalize(TransformWorldVectorToView(materialInput, material.WorldNormal));
-	float airIOR = 1.0f;
-#if USE_PIXEL_NORMAL_OFFSET_REFRACTION
-	float3 viewVertexNormal = TransformWorldVectorToView(materialInput, TransformTangentVectorToWorld(materialInput, float3(0, 0, 1)));
-	float2 distortion = (viewVertexNormal.xy - viewNormal.xy) * (material.Refraction - airIOR);
-#else
-	float2 distortion = viewNormal.xy * (material.Refraction - airIOR);
-#endif
-
-	// Clip if the distortion distance (squared) is too small to be noticed
-	clip(dot(distortion, distortion) - 0.00001);
-
-	// Scale up for better precision in low/subtle refractions at the expense of artefacts at higher refraction
-	distortion *= 4.0f;
-
-	// Store positive and negative offsets separately
-	float2 addOffset = max(distortion, 0);
-	float2 subOffset = abs(min(distortion, 0));
-	return float4(addOffset.x, addOffset.y, subOffset.x, subOffset.y);
-}
-
-#endif
-
 // Pixel Shader function for Depth Pass
 META_PS(true, FEATURE_LEVEL_ES2)
-void PS_Depth(PixelInput input
-#if GLSL
-	, out float4 OutColor : SV_Target0
-#endif
-	)
+void PS_Depth(PixelInput input)
 {
 	// Get material parameters
 	MaterialInput materialInput = GetMaterialInput(input);
@@ -861,8 +692,6 @@ void PS_Depth(PixelInput input
 #if MATERIAL_BLEND == MATERIAL_BLEND_TRANSPARENT
 	clip(material.Opacity - MATERIAL_OPACITY_THRESHOLD);
 #endif
-
-#if GLSL
-	OutColor = 0;
-#endif
 }
+
+@9
@@ -20,7 +20,7 @@ float4 ScreenSize;
 float4 TemporalAAJitter;
@1META_CB_END

-// Material shader resources
+// Shader resources
@2
 // Interpolants passed to the pixel shader
 struct PixelInput
@@ -128,16 +128,14 @@ float4 GetVertexColor(MaterialInput input)
 	return 1;
 }

+@8
+
 // Get material properties function (for pixel shader)
 Material GetMaterialPS(MaterialInput input)
 {
@4
 }

-// Programmatically set the line number after all the material inputs which have a variable number of line endings
-// This allows shader error line numbers after this point to be the same regardless of which material is being compiled
-#line 1000
-
 // Pixel Shader function for PostFx materials rendering
 META_PS(true, FEATURE_LEVEL_ES2)
 float4 PS_PostFx(PixelInput input) : SV_Target0
@@ -148,3 +146,5 @@ float4 PS_PostFx(PixelInput input) : SV_Target0

 	return float4(material.Emissive, material.Opacity);
 }
+
+@9
@@ -0,0 +1,618 @@
+// File generated by Flax Materials Editor
+// Version: @0
+
+#define MATERIAL 1
+@3
+#include "./Flax/Common.hlsl"
+#include "./Flax/MaterialCommon.hlsl"
+#include "./Flax/GBufferCommon.hlsl"
+@7
+// Primary constant buffer (with additional material parameters)
+META_CB_BEGIN(0, Data)
+float4x4 ViewProjectionMatrix;
+float4x4 WorldMatrix;
+float4x4 ViewMatrix;
+float4x4 PrevViewProjectionMatrix;
+float4x4 PrevWorldMatrix;
+float3 ViewPos;
+float ViewFar;
+float3 ViewDir;
+float TimeParam;
+float4 ViewInfo;
+float4 ScreenSize;
+float3 WorldInvScale;
+float WorldDeterminantSign;
+float2 Dummy0;
+float LODDitherFactor;
+float PerInstanceRandom;
+float4 TemporalAAJitter;
+float3 GeometrySize;
+float Dummy1;
+@1META_CB_END
+
+// Shader resources
+@2
+// Geometry data passed though the graphics rendering stages up to the pixel shader
+struct GeometryData
+{
+	float3 WorldPosition : TEXCOORD0;
+	float2 TexCoord : TEXCOORD1;
+	float2 LightmapUV : TEXCOORD2;
+#if USE_VERTEX_COLOR
+	half4 VertexColor : COLOR;
+#endif
+	float3 WorldNormal : TEXCOORD3;
+	float4 WorldTangent : TEXCOORD4;
+	float3 InstanceOrigin : TEXCOORD5;
+	float2 InstanceParams : TEXCOORD6; // x-PerInstanceRandom, y-LODDitherFactor
+	float3 PrevWorldPosition : TEXCOORD7;
+};
+
+// Interpolants passed from the vertex shader
+struct VertexOutput
+{
+	float4 Position : SV_Position;
+	GeometryData Geometry;
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	float4 CustomVSToPS[CUSTOM_VERTEX_INTERPOLATORS_COUNT] : TEXCOORD9;
+#endif
+#if USE_TESSELLATION
+    float TessellationMultiplier : TESS;
+#endif
+};
+
+// Interpolants passed to the pixel shader
+struct PixelInput
+{
+	float4 Position : SV_Position;
+	GeometryData Geometry;
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	float4 CustomVSToPS[CUSTOM_VERTEX_INTERPOLATORS_COUNT] : TEXCOORD9;
+#endif
+	bool IsFrontFace : SV_IsFrontFace;
+};
+
+// Material properties generation input
+struct MaterialInput
+{
+	float3 WorldPosition;
+	float TwoSidedSign;
+	float2 TexCoord;
+#if USE_LIGHTMAP
+	float2 LightmapUV;
+#endif
+#if USE_VERTEX_COLOR
+	half4 VertexColor;
+#endif
+	float3x3 TBN;
+	float4 SvPosition;
+	float3 PreSkinnedPosition;
+	float3 PreSkinnedNormal;
+	float3 InstanceOrigin;
+	float2 InstanceParams;
+#if USE_INSTANCING
+	float3 InstanceTransform1;
+	float3 InstanceTransform2;
+	float3 InstanceTransform3;
+#endif
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	float4 CustomVSToPS[CUSTOM_VERTEX_INTERPOLATORS_COUNT];
+#endif
+};
+
+// Extracts geometry data to the material input
+MaterialInput GetGeometryMaterialInput(GeometryData geometry)
+{
+	MaterialInput output = (MaterialInput)0;
+	output.WorldPosition = geometry.WorldPosition;
+	output.TexCoord = geometry.TexCoord;
+#if USE_LIGHTMAP
+	output.LightmapUV = geometry.LightmapUV;
+#endif
+#if USE_VERTEX_COLOR
+	output.VertexColor = geometry.VertexColor;
+#endif
+	output.TBN = CalcTangentBasis(geometry.WorldNormal, geometry.WorldTangent);
+	output.InstanceOrigin = geometry.InstanceOrigin;
+	output.InstanceParams = geometry.InstanceParams;
+	return output;
+}
+
+#if USE_TESSELLATION
+
+// Interpolates the geometry positions data only (used by the tessallation when generating vertices)
+#define InterpolateGeometryPositions(output, p0, w0, p1, w1, p2, w2, offset) output.WorldPosition = p0.WorldPosition * w0 + p1.WorldPosition * w1 + p2.WorldPosition * w2 + offset; output.PrevWorldPosition = p0.PrevWorldPosition * w0 + p1.PrevWorldPosition * w1 + p2.PrevWorldPosition * w2 + offset
+
+// Offsets the geometry positions data only (used by the tessallation when generating vertices)
+#define OffsetGeometryPositions(geometry, offset) geometry.WorldPosition += offset; geometry.PrevWorldPosition += offset
+
+// Applies the Phong tessallation to the geometry positions (used by the tessallation when doing Phong tess)
+#define ApplyGeometryPositionsPhongTess(geometry, p0, p1, p2, U, V, W) \
+	float3 posProjectedU = TessalationProjectOntoPlane(p0.WorldNormal, p0.WorldPosition, geometry.WorldPosition); \
+	float3 posProjectedV = TessalationProjectOntoPlane(p1.WorldNormal, p1.WorldPosition, geometry.WorldPosition); \
+	float3 posProjectedW = TessalationProjectOntoPlane(p2.WorldNormal, p2.WorldPosition, geometry.WorldPosition); \
+	geometry.WorldPosition = U * posProjectedU + V * posProjectedV + W * posProjectedW; \
+	posProjectedU = TessalationProjectOntoPlane(p0.WorldNormal, p0.PrevWorldPosition, geometry.PrevWorldPosition); \
+	posProjectedV = TessalationProjectOntoPlane(p1.WorldNormal, p1.PrevWorldPosition, geometry.PrevWorldPosition); \
+	posProjectedW = TessalationProjectOntoPlane(p2.WorldNormal, p2.PrevWorldPosition, geometry.PrevWorldPosition); \
+	geometry.PrevWorldPosition = U * posProjectedU + V * posProjectedV + W * posProjectedW
+
+// Interpolates the geometry data except positions (used by the tessallation when generating vertices)
+GeometryData InterpolateGeometry(GeometryData p0, float w0, GeometryData p1, float w1, GeometryData p2, float w2)
+{
+	GeometryData output = (GeometryData)0;
+	output.TexCoord = p0.TexCoord * w0 + p1.TexCoord * w1 + p2.TexCoord * w2;
+	output.LightmapUV = p0.LightmapUV * w0 + p1.LightmapUV * w1 + p2.LightmapUV * w2;
+#if USE_VERTEX_COLOR
+	output.VertexColor = p0.VertexColor * w0 + p1.VertexColor * w1 + p2.VertexColor * w2;
+#endif
+	output.WorldNormal = p0.WorldNormal * w0 + p1.WorldNormal * w1 + p2.WorldNormal * w2;
+	output.WorldNormal = normalize(output.WorldNormal);
+	output.WorldTangent = p0.WorldTangent * w0 + p1.WorldTangent * w1 + p2.WorldTangent * w2;
+	output.WorldTangent.xyz = normalize(output.WorldTangent.xyz);
+	output.InstanceOrigin = p0.InstanceOrigin;
+	output.InstanceParams = p0.InstanceParams;
+	return output;
+}
+
+#endif
+
+MaterialInput GetMaterialInput(PixelInput input)
+{
+	MaterialInput output = GetGeometryMaterialInput(input.Geometry);
+	output.TwoSidedSign = WorldDeterminantSign * (input.IsFrontFace ? 1.0 : -1.0);
+	output.SvPosition = input.Position;
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	output.CustomVSToPS = input.CustomVSToPS;
+#endif
+	return output;
+}
+
+// Gets the local to world transform matrix (supports instancing)
+#if USE_INSTANCING
+#define GetInstanceTransform(input) float4x4(float4(input.InstanceTransform1.xyz, 0.0f), float4(input.InstanceTransform2.xyz, 0.0f), float4(input.InstanceTransform3.xyz, 0.0f), float4(input.InstanceOrigin.xyz, 1.0f))
+#else
+#define GetInstanceTransform(input) WorldMatrix;
+#endif
+
+// Removes the scale vector from the local to world transformation matrix (supports instancing)
+float3x3 RemoveScaleFromLocalToWorld(float3x3 localToWorld)
+{
+#if USE_INSTANCING
+	// Extract per axis scales from localToWorld transform
+	float scaleX = length(localToWorld[0]);
+	float scaleY = length(localToWorld[1]);
+	float scaleZ = length(localToWorld[2]);
+	float3 invScale = float3(
+		scaleX > 0.00001f ? 1.0f / scaleX : 0.0f,
+		scaleY > 0.00001f ? 1.0f / scaleY : 0.0f,
+		scaleZ > 0.00001f ? 1.0f / scaleZ : 0.0f);
+#else
+	float3 invScale = WorldInvScale;
+#endif
+	localToWorld[0] *= invScale.x;
+	localToWorld[1] *= invScale.y;
+	localToWorld[2] *= invScale.z;
+	return localToWorld;
+}
+
+// Transforms a vector from tangent space to world space
+float3 TransformTangentVectorToWorld(MaterialInput input, float3 tangentVector)
+{
+	return mul(tangentVector, input.TBN);
+}
+
+// Transforms a vector from world space to tangent space
+float3 TransformWorldVectorToTangent(MaterialInput input, float3 worldVector)
+{
+	return mul(input.TBN, worldVector);
+}
+
+// Transforms a vector from world space to view space
+float3 TransformWorldVectorToView(MaterialInput input, float3 worldVector)
+{
+	return mul(worldVector, (float3x3)ViewMatrix);
+}
+
+// Transforms a vector from view space to world space
+float3 TransformViewVectorToWorld(MaterialInput input, float3 viewVector)
+{
+	return mul((float3x3)ViewMatrix, viewVector);
+}
+
+// Transforms a vector from local space to world space
+float3 TransformLocalVectorToWorld(MaterialInput input, float3 localVector)
+{
+	float3x3 localToWorld = (float3x3)GetInstanceTransform(input);
+	//localToWorld = RemoveScaleFromLocalToWorld(localToWorld);
+	return mul(localVector, localToWorld);
+}
+
+// Transforms a vector from local space to world space
+float3 TransformWorldVectorToLocal(MaterialInput input, float3 worldVector)
+{
+	float3x3 localToWorld = (float3x3)GetInstanceTransform(input);
+	//localToWorld = RemoveScaleFromLocalToWorld(localToWorld);
+	return mul(localToWorld, worldVector);
+}
+
+// Gets the current object position (supports instancing)
+float3 GetObjectPosition(MaterialInput input)
+{
+	return input.InstanceOrigin.xyz;
+}
+
+// Gets the current object size (supports instancing)
+float3 GetObjectSize(MaterialInput input)
+{
+	float4x4 world = GetInstanceTransform(input);
+	return GeometrySize * float3(world._m00, world._m11, world._m22);
+}
+
+// Get the current object random value (supports instancing)
+float GetPerInstanceRandom(MaterialInput input)
+{
+	return input.InstanceParams.x;
+}
+
+// Get the current object LOD transition dither factor (supports instancing)
+float GetLODDitherFactor(MaterialInput input)
+{
+#if USE_DITHERED_LOD_TRANSITION
+	return input.InstanceParams.y;
+#else
+	return 0;
+#endif
+}
+
+// Gets the interpolated vertex color (in linear space)
+float4 GetVertexColor(MaterialInput input)
+{
+#if USE_VERTEX_COLOR
+	return input.VertexColor;
+#else
+	return 1;
+#endif
+}
+
+@8
+
+// Get material properties function (for vertex shader)
+Material GetMaterialVS(MaterialInput input)
+{
+@5
+}
+
+// Get material properties function (for domain shader)
+Material GetMaterialDS(MaterialInput input)
+{
+@6
+}
+
+// Get material properties function (for pixel shader)
+Material GetMaterialPS(MaterialInput input)
+{
+@4
+}
+
+// Calculates the transform matrix from mesh tangent space to local space
+float3x3 CalcTangentToLocal(ModelInput input)
+{
+	float bitangentSign = input.Tangent.w ? -1.0f : +1.0f;
+	float3 normal = input.Normal.xyz * 2.0 - 1.0;
+	float3 tangent = input.Tangent.xyz * 2.0 - 1.0;
+	float3 bitangent = cross(normal, tangent) * bitangentSign;
+	return float3x3(tangent, bitangent, normal);
+}
+
+float3x3 CalcTangentToWorld(float4x4 world, float3x3 tangentToLocal)
+{
+	float3x3 localToWorld = RemoveScaleFromLocalToWorld((float3x3)world);
+	return mul(tangentToLocal, localToWorld); 
+}
+
+// Vertex Shader function for GBuffer Pass and Depth Pass (with full vertex data)
+META_VS(true, FEATURE_LEVEL_ES2)
+META_PERMUTATION_1(USE_INSTANCING=0)
+META_PERMUTATION_1(USE_INSTANCING=1)
+META_VS_IN_ELEMENT(POSITION, 0, R32G32B32_FLOAT,   0, 0,     PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(TEXCOORD, 0, R16G16_FLOAT,      1, 0,     PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(NORMAL,   0, R10G10B10A2_UNORM, 1, ALIGN, PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(TANGENT,  0, R10G10B10A2_UNORM, 1, ALIGN, PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(TEXCOORD, 1, R16G16_FLOAT,      1, ALIGN, PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(COLOR,    0, R8G8B8A8_UNORM,    2, 0,     PER_VERTEX, 0, USE_VERTEX_COLOR)
+META_VS_IN_ELEMENT(ATTRIBUTE,0, R32G32B32A32_FLOAT,3, 0,     PER_INSTANCE, 1, USE_INSTANCING)
+META_VS_IN_ELEMENT(ATTRIBUTE,1, R32G32B32A32_FLOAT,3, ALIGN, PER_INSTANCE, 1, USE_INSTANCING)
+META_VS_IN_ELEMENT(ATTRIBUTE,2, R32G32B32_FLOAT,   3, ALIGN, PER_INSTANCE, 1, USE_INSTANCING)
+META_VS_IN_ELEMENT(ATTRIBUTE,3, R32G32B32_FLOAT,   3, ALIGN, PER_INSTANCE, 1, USE_INSTANCING)
+META_VS_IN_ELEMENT(ATTRIBUTE,4, R16G16B16A16_FLOAT,3, ALIGN, PER_INSTANCE, 1, USE_INSTANCING)
+VertexOutput VS(ModelInput input)
+{
+	VertexOutput output;
+
+	// Compute world space vertex position
+	float4x4 world = GetInstanceTransform(input);
+	output.Geometry.WorldPosition = mul(float4(input.Position.xyz, 1), world).xyz;
+	output.Geometry.PrevWorldPosition = mul(float4(input.Position.xyz, 1), PrevWorldMatrix).xyz;
+
+	// Compute clip space position
+	output.Position = mul(float4(output.Geometry.WorldPosition, 1), ViewProjectionMatrix);
+
+	// Pass vertex attributes
+	output.Geometry.TexCoord = input.TexCoord;
+#if USE_VERTEX_COLOR
+	output.Geometry.VertexColor = input.Color;
+#endif
+	output.Geometry.InstanceOrigin = world[3].xyz;
+#if USE_INSTANCING
+	output.Geometry.LightmapUV = input.LightmapUV * input.InstanceLightmapArea.zw + input.InstanceLightmapArea.xy;
+	output.Geometry.InstanceParams = float2(input.InstanceOrigin.w, input.InstanceTransform1.w);
+#else
+#if CAN_USE_LIGHTMAP
+	output.Geometry.LightmapUV = input.LightmapUV * LightmapArea.zw + LightmapArea.xy;
+#else
+	output.Geometry.LightmapUV = input.LightmapUV;
+#endif
+	output.Geometry.InstanceParams = float2(PerInstanceRandom, LODDitherFactor);
+#endif
+
+	// Calculate tanget space to world space transformation matrix for unit vectors
+	float3x3 tangentToLocal = CalcTangentToLocal(input);
+	float3x3 tangentToWorld = CalcTangentToWorld(world, tangentToLocal);
+	output.Geometry.WorldNormal = tangentToWorld[2];
+	output.Geometry.WorldTangent.xyz = tangentToWorld[0];
+	output.Geometry.WorldTangent.w = input.Tangent.w ? -1.0f : +1.0f;
+
+	// Get material input params if need to evaluate any material property
+#if USE_POSITION_OFFSET || USE_TESSELLATION || USE_CUSTOM_VERTEX_INTERPOLATORS
+	MaterialInput materialInput = GetGeometryMaterialInput(output.Geometry);
+	materialInput.TwoSidedSign = WorldDeterminantSign;
+	materialInput.SvPosition = output.Position;
+	materialInput.PreSkinnedPosition = input.Position.xyz;
+	materialInput.PreSkinnedNormal = tangentToLocal[2].xyz;
+#if USE_INSTANCING
+	materialInput.InstanceTransform1 = input.InstanceTransform1.xyz;
+	materialInput.InstanceTransform2 = input.InstanceTransform2.xyz;
+	materialInput.InstanceTransform3 = input.InstanceTransform3.xyz;
+#endif
+	Material material = GetMaterialVS(materialInput);
+#endif
+
+	// Apply world position offset per-vertex
+#if USE_POSITION_OFFSET
+	output.Geometry.WorldPosition += material.PositionOffset;
+	output.Position = mul(float4(output.Geometry.WorldPosition, 1), ViewProjectionMatrix);
+#endif
+
+	// Get tessalation multiplier (per vertex)
+#if USE_TESSELLATION
+    output.TessellationMultiplier = material.TessellationMultiplier;
+#endif
+
+	// Copy interpolants for other shader stages
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	output.CustomVSToPS = material.CustomVSToPS;
+#endif
+
+	return output;
+}
+
+// Vertex Shader function for Depth Pass
+META_VS(true, FEATURE_LEVEL_ES2)
+META_PERMUTATION_1(USE_INSTANCING=0)
+META_PERMUTATION_1(USE_INSTANCING=1)
+META_VS_IN_ELEMENT(POSITION, 0, R32G32B32_FLOAT,   0, 0,     PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(ATTRIBUTE,0, R32G32B32A32_FLOAT,3, 0,     PER_INSTANCE, 1, USE_INSTANCING)
+META_VS_IN_ELEMENT(ATTRIBUTE,1, R32G32B32A32_FLOAT,3, ALIGN, PER_INSTANCE, 1, USE_INSTANCING)
+META_VS_IN_ELEMENT(ATTRIBUTE,2, R32G32B32_FLOAT,   3, ALIGN, PER_INSTANCE, 1, USE_INSTANCING)
+META_VS_IN_ELEMENT(ATTRIBUTE,3, R32G32B32_FLOAT,   3, ALIGN, PER_INSTANCE, 1, USE_INSTANCING)
+META_VS_IN_ELEMENT(ATTRIBUTE,4, R16G16B16A16_FLOAT,3, ALIGN, PER_INSTANCE, 1, USE_INSTANCING)
+float4 VS_Depth(ModelInput_PosOnly input) : SV_Position
+{
+	float4x4 world = GetInstanceTransform(input);
+	float3 worldPosition = mul(float4(input.Position.xyz, 1), world).xyz;
+	float4 position = mul(float4(worldPosition, 1), ViewProjectionMatrix);
+	return position;
+}
+
+#if USE_SKINNING
+
+// The skeletal bones matrix buffer (stored as 4x3, 3 float4 behind each other)
+Buffer<float4> BoneMatrices : register(t0);
+
+#if PER_BONE_MOTION_BLUR
+
+// The skeletal bones matrix buffer from the previous frame
+Buffer<float4> PrevBoneMatrices : register(t1);
+
+float3x4 GetPrevBoneMatrix(int index)
+{
+	float4 a = PrevBoneMatrices[index * 3];
+	float4 b = PrevBoneMatrices[index * 3 + 1];
+	float4 c = PrevBoneMatrices[index * 3 + 2];
+	return float3x4(a, b, c);
+}
+
+float3 SkinPrevPosition(ModelInput_Skinned input)
+{
+	float4 position = float4(input.Position.xyz, 1);
+	float3x4 boneMatrix = input.BlendWeights.x * GetPrevBoneMatrix(input.BlendIndices.x);
+	boneMatrix += input.BlendWeights.y * GetPrevBoneMatrix(input.BlendIndices.y);
+	boneMatrix += input.BlendWeights.z * GetPrevBoneMatrix(input.BlendIndices.z);
+	boneMatrix += input.BlendWeights.w * GetPrevBoneMatrix(input.BlendIndices.w);
+	return mul(boneMatrix, position);
+}
+
+#endif
+
+// Cached skinning data to avoid multiple calculation 
+struct SkinningData
+{
+	float3x4 BlendMatrix;
+};
+
+// Calculates the transposed transform matrix for the given bone index
+float3x4 GetBoneMatrix(int index)
+{
+	float4 a = BoneMatrices[index * 3];
+	float4 b = BoneMatrices[index * 3 + 1];
+	float4 c = BoneMatrices[index * 3 + 2];
+	return float3x4(a, b, c);
+}
+
+// Calculates the transposed transform matrix for the given vertex (uses blending)
+float3x4 GetBoneMatrix(ModelInput_Skinned input)
+{
+	float3x4 boneMatrix = input.BlendWeights.x * GetBoneMatrix(input.BlendIndices.x);
+	boneMatrix += input.BlendWeights.y * GetBoneMatrix(input.BlendIndices.y);
+	boneMatrix += input.BlendWeights.z * GetBoneMatrix(input.BlendIndices.z);
+	boneMatrix += input.BlendWeights.w * GetBoneMatrix(input.BlendIndices.w);
+	return boneMatrix;
+}
+
+// Transforms the vertex position by weighted sum of the skinning matrices
+float3 SkinPosition(ModelInput_Skinned input, SkinningData data)
+{
+	return mul(data.BlendMatrix, float4(input.Position.xyz, 1));
+}
+
+// Transforms the vertex position by weighted sum of the skinning matrices
+float3x3 SkinTangents(ModelInput_Skinned input, SkinningData data)
+{
+	// Unpack vertex tangent frame
+	float bitangentSign = input.Tangent.w ? -1.0f : +1.0f;
+	float3 normal = input.Normal.xyz * 2.0 - 1.0;
+	float3 tangent = input.Tangent.xyz * 2.0 - 1.0;
+
+	// Apply skinning
+	tangent = mul(data.BlendMatrix, float4(tangent, 0));
+	normal = mul(data.BlendMatrix, float4(normal, 0));
+
+	float3 bitangent = cross(normal, tangent) * bitangentSign;
+	return float3x3(tangent, bitangent, normal);
+}
+
+// Vertex Shader function for GBuffers/Depth Pass (skinned mesh rendering)
+META_VS(true, FEATURE_LEVEL_ES2)
+META_PERMUTATION_1(USE_SKINNING=1)
+META_PERMUTATION_2(USE_SKINNING=1, PER_BONE_MOTION_BLUR=1)
+META_VS_IN_ELEMENT(POSITION,     0, R32G32B32_FLOAT,   0, 0,     PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(TEXCOORD,     0, R16G16_FLOAT,      0, ALIGN, PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(NORMAL,       0, R10G10B10A2_UNORM, 0, ALIGN, PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(TANGENT,      0, R10G10B10A2_UNORM, 0, ALIGN, PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(BLENDINDICES, 0, R8G8B8A8_UINT,     0, ALIGN, PER_VERTEX, 0, true)
+META_VS_IN_ELEMENT(BLENDWEIGHT,  0, R16G16B16A16_FLOAT,0, ALIGN, PER_VERTEX, 0, true)
+VertexOutput VS_Skinned(ModelInput_Skinned input)
+{
+	VertexOutput output;
+	
+	// Perform skinning
+	SkinningData data;
+	data.BlendMatrix = GetBoneMatrix(input);
+	float3 position = SkinPosition(input, data);
+	float3x3 tangentToLocal = SkinTangents(input, data);
+	
+	// Compute world space vertex position
+	float4x4 world = GetInstanceTransform(input);
+	output.Geometry.WorldPosition = mul(float4(position, 1), world).xyz;
+#if PER_BONE_MOTION_BLUR
+	float3 prevPosition = SkinPrevPosition(input);
+	output.Geometry.PrevWorldPosition = mul(float4(prevPosition, 1), PrevWorldMatrix).xyz;
+#else
+	output.Geometry.PrevWorldPosition = mul(float4(position, 1), PrevWorldMatrix).xyz;
+#endif
+
+	// Compute clip space position
+	output.Position = mul(float4(output.Geometry.WorldPosition, 1), ViewProjectionMatrix);
+
+	// Pass vertex attributes
+	output.Geometry.TexCoord = input.TexCoord;
+#if USE_VERTEX_COLOR
+	output.Geometry.VertexColor = float4(0, 0, 0, 1);
+#endif
+	output.Geometry.LightmapUV = float2(0, 0);
+	output.Geometry.InstanceOrigin = world[3].xyz;
+#if USE_INSTANCING
+	output.Geometry.InstanceParams = float2(input.InstanceOrigin.w, input.InstanceTransform1.w);
+#else
+	output.Geometry.InstanceParams = float2(PerInstanceRandom, LODDitherFactor);
+#endif
+
+	// Calculate tanget space to world space transformation matrix for unit vectors
+	float3x3 tangentToWorld = CalcTangentToWorld(world, tangentToLocal);
+	output.Geometry.WorldNormal = tangentToWorld[2];
+	output.Geometry.WorldTangent.xyz = tangentToWorld[0];
+	output.Geometry.WorldTangent.w = input.Tangent.w ? -1.0f : +1.0f;
+
+	// Get material input params if need to evaluate any material property
+#if USE_POSITION_OFFSET || USE_TESSELLATION || USE_CUSTOM_VERTEX_INTERPOLATORS
+	MaterialInput materialInput = GetGeometryMaterialInput(output.Geometry);
+	materialInput.TwoSidedSign = WorldDeterminantSign;
+	materialInput.SvPosition = output.Position;
+	materialInput.PreSkinnedPosition = input.Position.xyz;
+	materialInput.PreSkinnedNormal = tangentToLocal[2].xyz;
+	Material material = GetMaterialVS(materialInput);
+#endif
+
+	// Apply world position offset per-vertex
+#if USE_POSITION_OFFSET
+	output.Geometry.WorldPosition += material.PositionOffset;
+	output.Position = mul(float4(output.Geometry.WorldPosition, 1), ViewProjectionMatrix);
+#endif
+
+	// Get tessalation multiplier (per vertex)
+#if USE_TESSELLATION
+    output.TessellationMultiplier = material.TessellationMultiplier;
+#endif
+	
+	// Copy interpolants for other shader stages
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	output.CustomVSToPS = material.CustomVSToPS;
+#endif
+
+	return output;
+}
+
+#endif
+
+#if USE_DITHERED_LOD_TRANSITION
+
+void ClipLODTransition(PixelInput input)
+{
+	float ditherFactor = input.Geometry.InstanceParams.y;
+	if (abs(ditherFactor) > 0.001)
+	{
+		float randGrid = cos(dot(floor(input.Position.xy), float2(347.83452793, 3343.28371863)));
+		float randGridFrac = frac(randGrid * 1000.0);
+		half mask = (ditherFactor < 0.0) ? (ditherFactor + 1.0 > randGridFrac) : (ditherFactor < randGridFrac);
+		clip(mask - 0.001);
+	}
+}
+
+#endif
+
+// Pixel Shader function for Depth Pass
+META_PS(true, FEATURE_LEVEL_ES2)
+void PS_Depth(PixelInput input)
+{	
+#if USE_DITHERED_LOD_TRANSITION
+	// LOD masking
+	ClipLODTransition(input);
+#endif
+
+#if MATERIAL_MASKED || MATERIAL_BLEND != MATERIAL_BLEND_OPAQUE 
+	// Get material parameters
+	MaterialInput materialInput = GetMaterialInput(input);
+	Material material = GetMaterialPS(materialInput);
+
+	// Perform per pixel clipping
+#if MATERIAL_MASKED
+	clip(material.Mask - MATERIAL_MASK_THRESHOLD);
+#endif
+#if MATERIAL_BLEND != MATERIAL_BLEND_OPAQUE
+	clip(material.Opacity - MATERIAL_OPACITY_THRESHOLD);
+#endif
+#endif
+}
+
+@9
@@ -3,7 +3,6 @@

 #define MATERIAL 1
@3
-
 // Enables/disables smooth terrain chunks LOD transitions (with morphing higher LOD near edges to the lower LOD in the neighbour)
 #define USE_SMOOTH_LOD_TRANSITION 1

@@ -26,7 +25,6 @@ float3 ViewDir;
 float TimeParam;
 float4 ViewInfo;
 float4 ScreenSize;
-float4 LightmapArea;
 float3 WorldInvScale;
 float WorldDeterminantSign;
 float PerInstanceRandom;
@@ -39,27 +37,16 @@ float2 OffsetUV;
 float2 Dummy0;
@1META_CB_END

-#if CAN_USE_LIGHTMAP
-
-// Irradiance and directionality prebaked lightmaps
-Texture2D Lightmap0 : register(t0);
-Texture2D Lightmap1 : register(t1);
-Texture2D Lightmap2 : register(t2);
-
-#endif
-
 // Terrain data
-Texture2D Heightmap : register(t3);
-Texture2D Splatmap0 : register(t4);
-Texture2D Splatmap1 : register(t5);
+Texture2D Heightmap : register(t0);
+Texture2D Splatmap0 : register(t1);
+Texture2D Splatmap1 : register(t2);

-// Material shader resources
+// Shader resources
@2
-
-// Interpolants passed from the vertex shader
-struct VertexOutput
+// Geometry data passed though the graphics rendering stages up to the pixel shader
+struct GeometryData
 {
-	float4 Position          : SV_Position;
 	float3 WorldPosition : TEXCOORD0;
 	float2 TexCoord : TEXCOORD1;
 	float2 LightmapUV : TEXCOORD2;
@@ -68,6 +55,13 @@ struct VertexOutput
 #if USE_TERRAIN_LAYERS
 	float4 Layers[TERRAIN_LAYERS_DATA_SIZE] : TEXCOORD5;
 #endif
+};
+
+// Interpolants passed from the vertex shader
+struct VertexOutput
+{
+	float4 Position : SV_Position;
+	GeometryData Geometry;
 #if USE_CUSTOM_VERTEX_INTERPOLATORS
 	float4 CustomVSToPS[CUSTOM_VERTEX_INTERPOLATORS_COUNT] : TEXCOORD9;
 #endif
@@ -80,14 +74,7 @@ struct VertexOutput
 struct PixelInput
 {
 	float4 Position : SV_Position;
-	float3 WorldPosition     : TEXCOORD0;
-	float2 TexCoord          : TEXCOORD1;
-	float2 LightmapUV        : TEXCOORD2;
-	float3 WorldNormal       : TEXCOORD3;
-	float HolesMask          : TEXCOORD4;
-#if USE_TERRAIN_LAYERS
-	float4 Layers[TERRAIN_LAYERS_DATA_SIZE] : TEXCOORD5;
-#endif
+	GeometryData Geometry;
 #if USE_CUSTOM_VERTEX_INTERPOLATORS
 	float4 CustomVSToPS[CUSTOM_VERTEX_INTERPOLATORS_COUNT] : TEXCOORD9;
 #endif
@@ -116,25 +103,66 @@ struct MaterialInput
 #endif
 };

+// Extracts geometry data to the material input
+MaterialInput GetGeometryMaterialInput(GeometryData geometry)
+{
+	MaterialInput output = (MaterialInput)0;
+	output.WorldPosition = geometry.WorldPosition;
+	output.TexCoord = geometry.TexCoord;
+#if USE_LIGHTMAP
+	output.LightmapUV = geometry.LightmapUV;
+#endif
+	output.TBN = CalcTangentBasis(geometry.WorldNormal, geometry.WorldPosition, geometry.TexCoord);
+	output.HolesMask = geometry.HolesMask;
+#if USE_TERRAIN_LAYERS
+	output.Layers = geometry.Layers;
+#endif
+	return output;
+}
+
+#if USE_TESSELLATION
+
+// Interpolates the geometry positions data only (used by the tessallation when generating vertices)
+#define InterpolateGeometryPositions(output, p0, w0, p1, w1, p2, w2, offset) output.WorldPosition = p0.WorldPosition * w0 + p1.WorldPosition * w1 + p2.WorldPosition * w2 + offset
+
+// Offsets the geometry positions data only (used by the tessallation when generating vertices)
+#define OffsetGeometryPositions(geometry, offset) geometry.WorldPosition += offset
+
+// Applies the Phong tessallation to the geometry positions (used by the tessallation when doing Phong tess)
+#define ApplyGeometryPositionsPhongTess(geometry, p0, p1, p2, U, V, W) \
+	float3 posProjectedU = TessalationProjectOntoPlane(p0.WorldNormal, p0.WorldPosition, geometry.WorldPosition); \
+	float3 posProjectedV = TessalationProjectOntoPlane(p1.WorldNormal, p1.WorldPosition, geometry.WorldPosition); \
+	float3 posProjectedW = TessalationProjectOntoPlane(p2.WorldNormal, p2.WorldPosition, geometry.WorldPosition); \
+	geometry.WorldPosition = U * posProjectedU + V * posProjectedV + W * posProjectedW
+
+// Interpolates the geometry data except positions (used by the tessallation when generating vertices)
+GeometryData InterpolateGeometry(GeometryData p0, float w0, GeometryData p1, float w1, GeometryData p2, float w2)
+{
+	GeometryData output = (GeometryData)0;
+	output.TexCoord = p0.TexCoord * w0 + p1.TexCoord * w1 + p2.TexCoord * w2;
+	output.LightmapUV = p0.LightmapUV * w0 + p1.LightmapUV * w1 + p2.LightmapUV * w2;
+	output.WorldNormal = p0.WorldNormal * w0 + p1.WorldNormal * w1 + p2.WorldNormal * w2;
+	output.WorldNormal = normalize(output.WorldNormal);
+	output.HolesMask = p0.HolesMask * w0 + p1.HolesMask * w1 + p2.HolesMask * w2;
+#if USE_TERRAIN_LAYERS
+	UNROLL
+	for (int i = 0; i < TERRAIN_LAYERS_DATA_SIZE; i++)
+		output.Layers[i] = p0.Layers[i] * w0 + p1.Layers[i] * w1 + p2.Layers[i] * w2;
+#endif
+	return output;
+}
+
+#endif
+
 MaterialInput GetMaterialInput(PixelInput input)
 {
-	MaterialInput result = (MaterialInput)0;
-	result.WorldPosition = input.WorldPosition;
-	result.TexCoord = input.TexCoord;
-#if USE_LIGHTMAP
-	result.LightmapUV = input.LightmapUV;
-#endif
-	result.TBN = CalcTangentBasisFromWorldNormal(input.WorldNormal);
-	result.TwoSidedSign = WorldDeterminantSign * (input.IsFrontFace ? 1.0 : -1.0);
-	result.SvPosition = input.Position;
-	result.HolesMask = input.HolesMask;
-#if USE_TERRAIN_LAYERS
-	result.Layers = input.Layers;
-#endif
+	MaterialInput output = GetGeometryMaterialInput(input.Geometry);
+	output.TwoSidedSign = WorldDeterminantSign * (input.IsFrontFace ? 1.0 : -1.0);
+	output.SvPosition = input.Position;
 #if USE_CUSTOM_VERTEX_INTERPOLATORS
-	result.CustomVSToPS = input.CustomVSToPS;
+	output.CustomVSToPS = input.CustomVSToPS;
 #endif
-	return result;
+	return output;
 }

 // Removes the scale vector from the local to world transformation matrix
@@ -216,6 +244,8 @@ float4 GetVertexColor(MaterialInput input)
 	return 1;
 }

+@8
+
 // Get material properties function (for vertex shader)
 Material GetMaterialVS(MaterialInput input)
 {
@@ -234,10 +264,6 @@ Material GetMaterialPS(MaterialInput input)
@4
 }

-// Programmatically set the line number after all the material inputs which have a variable number of line endings
-// This allows shader error line numbers after this point to be the same regardless of which material is being compiled
-#line 1000
-
 // Calculates LOD value (with fractional part for blending)
 float CalcLOD(float2 xy, float4 morph)
 {
@@ -337,7 +363,7 @@ VertexOutput VS(TerrainVertexInput input)
 	float2 normalTemp = float2(heightmapValue.b, heightmapValue.a) * 2.0f - 1.0f;
 	float3 normal = float3(normalTemp.x, sqrt(1.0 - saturate(dot(normalTemp, normalTemp))), normalTemp.y);
 	normal = normalize(normal);
-	output.HolesMask = isHole ? 0 : 1;
+	output.Geometry.HolesMask = isHole ? 0 : 1;
 	if (isHole)
 	{
 		normal = float3(0, 1, 0);
@@ -354,10 +380,10 @@ VertexOutput VS(TerrainVertexInput input)
 	float3 position = float3(positionXZ.x, height, positionXZ.y);

 	// Compute world space vertex position
-	output.WorldPosition = mul(float4(position, 1), WorldMatrix).xyz;
+	output.Geometry.WorldPosition = mul(float4(position, 1), WorldMatrix).xyz;

 	// Compute clip space position
-	output.Position = mul(float4(output.WorldPosition.xyz, 1), ViewProjectionMatrix);
+	output.Position = mul(float4(output.Geometry.WorldPosition, 1), ViewProjectionMatrix);

 	// Pass vertex attributes
 #if USE_SMOOTH_LOD_TRANSITION
@@ -365,46 +391,46 @@ VertexOutput VS(TerrainVertexInput input)
 #else
 	float2 texCoord = input.TexCoord;
 #endif
-	output.TexCoord = positionXZ * (1.0f / TerrainChunkSizeLOD0) + OffsetUV;
-	output.LightmapUV = texCoord * LightmapArea.zw + LightmapArea.xy;
+	output.Geometry.TexCoord = positionXZ * (1.0f / TerrainChunkSizeLOD0) + OffsetUV;
+	output.Geometry.LightmapUV = texCoord * LightmapArea.zw + LightmapArea.xy;

 	// Extract terrain layers weights from the splatmap
 #if USE_TERRAIN_LAYERS
-	output.Layers[0] = splatmap0Value;
+	output.Geometry.Layers[0] = splatmap0Value;
 #if TERRAIN_LAYERS_DATA_SIZE > 1
-	output.Layers[1] = splatmap1Value;
+	output.Geometry.Layers[1] = splatmap1Value;
 #endif
 #endif

 	// Compute world space normal vector
 	float3x3 tangentToLocal = CalcTangentBasisFromWorldNormal(normal);
 	float3x3 tangentToWorld = CalcTangentToWorld(WorldMatrix, tangentToLocal);
-	output.WorldNormal = tangentToWorld[2];
+	output.Geometry.WorldNormal = tangentToWorld[2];

 	// Get material input params if need to evaluate any material property
 #if USE_POSITION_OFFSET || USE_TESSELLATION || USE_CUSTOM_VERTEX_INTERPOLATORS
 	MaterialInput materialInput = (MaterialInput)0;
-	materialInput.WorldPosition = output.WorldPosition;
-	materialInput.TexCoord = output.TexCoord;
+	materialInput.WorldPosition = output.Geometry.WorldPosition;
+	materialInput.TexCoord = output.Geometry.TexCoord;
 #if USE_LIGHTMAP
-	materialInput.LightmapUV = output.LightmapUV;
+	materialInput.LightmapUV = output.Geometry.LightmapUV;
 #endif
-	materialInput.TBN = CalcTangentBasisFromWorldNormal(output.WorldNormal);
+	materialInput.TBN = tangentToWorld;
 	materialInput.TwoSidedSign = WorldDeterminantSign;
 	materialInput.SvPosition = output.Position;
 	materialInput.PreSkinnedPosition = position;
 	materialInput.PreSkinnedNormal = normal;
-	materialInput.HolesMask = output.HolesMask;
+	materialInput.HolesMask = output.Geometry.HolesMask;
 #if USE_TERRAIN_LAYERS
-	materialInput.Layers = output.Layers;
+	materialInput.Layers = output.Geometry.Layers;
 #endif
 	Material material = GetMaterialVS(materialInput);
 #endif

 	// Apply world position offset per-vertex
 #if USE_POSITION_OFFSET
-	output.WorldPosition += material.PositionOffset;
-	output.Position = mul(float4(output.WorldPosition.xyz, 1), ViewProjectionMatrix);
+	output.Geometry.WorldPosition += material.PositionOffset;
+	output.Position = mul(float4(output.Geometry.WorldPosition, 1), ViewProjectionMatrix);
 #endif

 	// Get tessalation multiplier (per vertex)
@@ -420,357 +446,9 @@ VertexOutput VS(TerrainVertexInput input)
 	return output;
 }

-#if USE_TESSELLATION
-
-// Interpolants passed from the hull shader to the domain shader
-struct TessalationHSToDS
-{
-	float4 Position          : SV_Position;
-	float3 WorldPosition     : TEXCOORD0;
-	float2 TexCoord          : TEXCOORD1;
-	float2 LightmapUV        : TEXCOORD2;
-	float3 WorldNormal       : TEXCOORD3;
-	float HolesMask          : TEXCOORD4;
-#if USE_TERRAIN_LAYERS
-	float4 Layers[TERRAIN_LAYERS_DATA_SIZE] : TEXCOORD5;
-#endif
-#if USE_CUSTOM_VERTEX_INTERPOLATORS
-	float4 CustomVSToPS[CUSTOM_VERTEX_INTERPOLATORS_COUNT] : TEXCOORD9;
-#endif
-	float TessellationMultiplier : TESS;
-};
-
-// Interpolants passed from the domain shader and to the pixel shader
-struct TessalationDSToPS
-{
-	float4 Position          : SV_Position;
-	float3 WorldPosition     : TEXCOORD0;
-	float2 TexCoord          : TEXCOORD1;
-	float2 LightmapUV        : TEXCOORD2;
-	float3 WorldNormal       : TEXCOORD3;
-	float HolesMask          : TEXCOORD4;
-#if USE_TERRAIN_LAYERS
-	float4 Layers[TERRAIN_LAYERS_DATA_SIZE] : TEXCOORD5;
-#endif
-#if USE_CUSTOM_VERTEX_INTERPOLATORS
-	float4 CustomVSToPS[CUSTOM_VERTEX_INTERPOLATORS_COUNT] : TEXCOORD9;
-#endif
-};
-
-MaterialInput GetMaterialInput(TessalationDSToPS input)
-{
-	MaterialInput result = (MaterialInput)0;
-	result.WorldPosition = input.WorldPosition;
-	result.TexCoord = input.TexCoord;
-#if USE_LIGHTMAP
-	result.LightmapUV = input.LightmapUV;
-#endif
-	result.TBN = CalcTangentBasisFromWorldNormal(input.WorldNormal);
-	result.TwoSidedSign = WorldDeterminantSign;
-	result.SvPosition = input.Position;
-	result.HolesMask = input.HolesMask;
-#if USE_TERRAIN_LAYERS
-	result.Layers = input.Layers;
-#endif
-#if USE_CUSTOM_VERTEX_INTERPOLATORS
-	result.CustomVSToPS = input.CustomVSToPS;
-#endif
-	return result;
-}
-
-struct TessalationPatch
-{
-	float EdgeTessFactor[3] : SV_TessFactor;
-	float InsideTessFactor  : SV_InsideTessFactor;
-#if MATERIAL_TESSELLATION == MATERIAL_TESSELLATION_PN
-	float3 B210 : POSITION4;
-	float3 B120 : POSITION5;
-	float3 B021 : POSITION6;
-	float3 B012 : POSITION7;
-	float3 B102 : POSITION8;
-	float3 B201 : POSITION9;
-	float3 B111 : CENTER;
-#endif
-};
-
-TessalationPatch HS_PatchConstant(InputPatch<VertexOutput, 3> input)
-{
-	TessalationPatch output;
-
-	// Average tess factors along edges, and pick an edge tess factor for the interior tessellation
-	float4 TessellationMultipliers;
-	TessellationMultipliers.x = 0.5f * (input[1].TessellationMultiplier + input[2].TessellationMultiplier);
-	TessellationMultipliers.y = 0.5f * (input[2].TessellationMultiplier + input[0].TessellationMultiplier);
-	TessellationMultipliers.z = 0.5f * (input[0].TessellationMultiplier + input[1].TessellationMultiplier);
-	TessellationMultipliers.w = 0.333f * (input[0].TessellationMultiplier + input[1].TessellationMultiplier + input[2].TessellationMultiplier);
-
-	TessellationMultipliers = clamp(TessellationMultipliers, 1, MAX_TESSELLATION_FACTOR);
-
-	output.EdgeTessFactor[0] = TessellationMultipliers.x; // 1->2 edge
-	output.EdgeTessFactor[1] = TessellationMultipliers.y; // 2->0 edge
-	output.EdgeTessFactor[2] = TessellationMultipliers.z; // 0->1 edge
-	output.InsideTessFactor  = TessellationMultipliers.w;
-
-#if MATERIAL_TESSELLATION == MATERIAL_TESSELLATION_PN
-	// Calculate PN-Triangle coefficients
-	// Refer to Vlachos 2001 for the original formula
-	float3 p1 = input[0].WorldPosition;
-	float3 p2 = input[1].WorldPosition;
-	float3 p3 = input[2].WorldPosition;
-	float3 n1 = input[0].WorldNormal;
-	float3 n2 = input[1].WorldNormal;
-	float3 n3 = input[2].WorldNormal;
-
-	// Calculate control points
-	output.B210 = (2.0f * p1 + p2 - dot((p2 - p1), n1) * n1) / 3.0f;
-	output.B120 = (2.0f * p2 + p1 - dot((p1 - p2), n2) * n2) / 3.0f;
-	output.B021 = (2.0f * p2 + p3 - dot((p3 - p2), n2) * n2) / 3.0f;
-	output.B012 = (2.0f * p3 + p2 - dot((p2 - p3), n3) * n3) / 3.0f;
-	output.B102 = (2.0f * p3 + p1 - dot((p1 - p3), n3) * n3) / 3.0f;
-	output.B201 = (2.0f * p1 + p3 - dot((p3 - p1), n1) * n1) / 3.0f;
-	float3 e = (output.B210 + output.B120 + output.B021 + 
-	output.B012 + output.B102 + output.B201) / 6.0f;
-	float3 v = (p1 + p2 + p3) / 3.0f;
-	output.B111 = e + ((e - v) / 2.0f);
-#endif
-
-	return output;
-}
-
-META_HS(USE_TESSELLATION, FEATURE_LEVEL_SM5)
-META_HS_PATCH(TESSELLATION_IN_CONTROL_POINTS)
-[domain("tri")]
-[partitioning("fractional_odd")]
-[outputtopology("triangle_cw")]
-[maxtessfactor(MAX_TESSELLATION_FACTOR)]
-[outputcontrolpoints(3)]
-[patchconstantfunc("HS_PatchConstant")]
-TessalationHSToDS HS(InputPatch<VertexOutput, TESSELLATION_IN_CONTROL_POINTS> input, uint ControlPointID : SV_OutputControlPointID)
-{
-	TessalationHSToDS output;
-
-	// Pass through shader
-#define COPY(thing) output.thing = input[ControlPointID].thing;
-	COPY(Position);
-	COPY(WorldPosition);
-	COPY(TexCoord);
-	COPY(LightmapUV);
-	COPY(WorldNormal);
-	COPY(HolesMask);
-	COPY(TessellationMultiplier);
-#if USE_TERRAIN_LAYERS
-	COPY(Layers);
-#endif
-#if USE_CUSTOM_VERTEX_INTERPOLATORS
-	COPY(CustomVSToPS);
-#endif
-#undef COPY
-
-	return output;
-}
-
-#if MATERIAL_TESSELLATION == MATERIAL_TESSELLATION_PHONG
-
-// Orthogonal projection on to plane
-float3 ProjectOntoPlane(float3 planeNormal, float3 planePoint, float3 pointToProject)
-{
-    return pointToProject - dot(pointToProject-planePoint, planeNormal) * planeNormal;
-}
-
-#endif
-
-META_DS(USE_TESSELLATION, FEATURE_LEVEL_SM5)
-[domain("tri")]
-TessalationDSToPS DS(TessalationPatch constantData, float3 barycentricCoords : SV_DomainLocation, const OutputPatch<TessalationHSToDS, 3> input)
-{
-	TessalationDSToPS output;
-
-	// Get the barycentric coords
-	float U = barycentricCoords.x;
-	float V = barycentricCoords.y;
-	float W = barycentricCoords.z;
-
-	// Interpolate patch attributes to generated vertices
-#define INTERPOLATE(thing) output.thing = U * input[0].thing + V * input[1].thing + W * input[2].thing
-#define COPY(thing) output.thing = input[0].thing
-	INTERPOLATE(Position);
-#if MATERIAL_TESSELLATION == MATERIAL_TESSELLATION_PN
-	// Precompute squares and squares * 3 
-	float UU = U * U;
-	float VV = V * V;
-	float WW = W * W;
-	float UU3 = UU * 3.0f;
-	float VV3 = VV * 3.0f;
-	float WW3 = WW * 3.0f;
-
-	// Interpolate using barycentric coordinates and PN Triangle control points
-	output.WorldPosition =
-		input[0].WorldPosition * UU * U +
-		input[1].WorldPosition * VV * V + 
-		input[2].WorldPosition * WW * W + 
-		constantData.B210 * UU3 * V +
-		constantData.B120 * VV3 * U +
-		constantData.B021 * VV3 * W +
-		constantData.B012 * WW3 * V +
-		constantData.B102 * WW3 * U +
-		constantData.B201 * UU3 * W +
-		constantData.B111 * 6.0f * W * U * V;
-#else
-	INTERPOLATE(WorldPosition);
-#endif
-	INTERPOLATE(TexCoord);
-	INTERPOLATE(LightmapUV);
-	INTERPOLATE(WorldNormal);
-	INTERPOLATE(HolesMask);
-#if USE_TERRAIN_LAYERS
-	UNROLL
-	for (int i = 0; i < TERRAIN_LAYERS_DATA_SIZE; i++)
-	{
-		INTERPOLATE(Layers[i]);
-	}
-#endif
-#if USE_CUSTOM_VERTEX_INTERPOLATORS
-	UNROLL
-	for (int i = 0; i < CUSTOM_VERTEX_INTERPOLATORS_COUNT; i++)
-	{
-		INTERPOLATE(CustomVSToPS[i]);
-	}
-#endif
-#undef INTERPOLATE
-#undef COPY
-
-	// Interpolating normal can unnormalize it, so normalize it
-	output.WorldNormal = normalize(output.WorldNormal);
-
-#if MATERIAL_TESSELLATION == MATERIAL_TESSELLATION_PHONG
-	// Orthogonal projection in the tangent planes
-	float3 posProjectedU = ProjectOntoPlane(input[0].WorldNormal, input[0].WorldPosition, output.WorldPosition);
-	float3 posProjectedV = ProjectOntoPlane(input[1].WorldNormal, input[1].WorldPosition, output.WorldPosition);
-	float3 posProjectedW = ProjectOntoPlane(input[2].WorldNormal, input[2].WorldPosition, output.WorldPosition);
-
-	// Interpolate the projected points
-	output.WorldPosition = U * posProjectedU + V * posProjectedV + W * posProjectedW;
-#endif
-
-	// Perform displacement mapping
-#if USE_DISPLACEMENT
-	MaterialInput materialInput = GetMaterialInput(output);
-	Material material = GetMaterialDS(materialInput);
-	output.WorldPosition += material.WorldDisplacement;
-#endif
-
-	// Recalculate the clip space position
-	output.Position = mul(float4(output.WorldPosition, 1), ViewProjectionMatrix);
-
-	return output;
-}
-
-#endif
-
-#if USE_LIGHTMAP
-
-float3 SampleLightmap(Material material, MaterialInput materialInput)
-{
-	// Sample lightmaps
-	float4 lightmap0 = Lightmap0.Sample(SamplerLinearClamp, materialInput.LightmapUV);
-	float4 lightmap1 = Lightmap1.Sample(SamplerLinearClamp, materialInput.LightmapUV);
-	float4 lightmap2 = Lightmap2.Sample(SamplerLinearClamp, materialInput.LightmapUV);
-
-	// Unpack H-basis
-	float3 h0 = float3(lightmap0.x, lightmap1.x, lightmap2.x);
-	float3 h1 = float3(lightmap0.y, lightmap1.y, lightmap2.y);
-	float3 h2 = float3(lightmap0.z, lightmap1.z, lightmap2.z);
-	float3 h3 = float3(lightmap0.w, lightmap1.w, lightmap2.w);
-
-	// Sample baked diffuse irradiance from the H-basis coefficients
-	float3 normal = material.TangentNormal;
-#if MATERIAL_SHADING_MODEL == SHADING_MODEL_FOLIAGE
-	normal *= material.TangentNormal;
-#endif
-	return GetHBasisIrradiance(normal, h0, h1, h2, h3) / PI;
-}
-
-#endif
-
-// Pixel Shader function for GBuffer Pass
-META_PS(true, FEATURE_LEVEL_ES2)
-META_PERMUTATION_1(USE_LIGHTMAP=0)
-META_PERMUTATION_1(USE_LIGHTMAP=1)
-void PS_GBuffer(
-		in PixelInput input
-		,out float4 Light : SV_Target0
-#if MATERIAL_BLEND == MATERIAL_BLEND_OPAQUE
-		,out float4 RT0   : SV_Target1
-		,out float4 RT1   : SV_Target2
-		,out float4 RT2   : SV_Target3
-#if USE_GBUFFER_CUSTOM_DATA
-		,out float4 RT3   : SV_Target4
-#endif
-#endif
-	)
-{
-	Light = 0;
-
-	// Get material parameters
-	MaterialInput materialInput = GetMaterialInput(input);
-	Material material = GetMaterialPS(materialInput);
-
-	// Masking
-#if MATERIAL_MASKED
-	clip(material.Mask - MATERIAL_MASK_THRESHOLD);
-#endif
-	
-#if USE_LIGHTMAP
-
-	float3 diffuseColor = GetDiffuseColor(material.Color, material.Metalness);
-	float3 specularColor = GetSpecularColor(material.Color, material.Specular, material.Metalness);
-
-	// Sample lightmap
-	float3 diffuseIndirectLighting = SampleLightmap(material, materialInput);
-
-	// Apply static indirect light
-	Light.rgb = diffuseColor * diffuseIndirectLighting * AOMultiBounce(material.AO, diffuseColor);
-
-#endif
-
-#if MATERIAL_BLEND == MATERIAL_BLEND_OPAQUE
-
-	// Pack material properties to GBuffer
-	RT0 = float4(material.Color, material.AO);
-	RT1 = float4(material.WorldNormal * 0.5 + 0.5, MATERIAL_SHADING_MODEL * (1.0 / 3.0));
-	RT2 = float4(material.Roughness, material.Metalness, material.Specular, 0);
-
-	// Custom data
-#if USE_GBUFFER_CUSTOM_DATA
-#if MATERIAL_SHADING_MODEL == SHADING_MODEL_SUBSURFACE
-	RT3 = float4(material.SubsurfaceColor, material.Opacity);
-#elif MATERIAL_SHADING_MODEL == SHADING_MODEL_FOLIAGE
-	RT3 = float4(material.SubsurfaceColor, material.Opacity);
-#else
-	RT3 = float4(0, 0, 0, 0);
-#endif
-#endif
-
-	// Add light emission
-#if USE_EMISSIVE
-	Light.rgb += material.Emissive;
-#endif
-
-#else
-
-	// Handle blending as faked forward pass (use Light buffer and skip GBuffer modification)
-	Light = float4(material.Emissive, material.Opacity);
-
-#endif
-}
-
 // Pixel Shader function for Depth Pass
 META_PS(true, FEATURE_LEVEL_ES2)
-void PS_Depth(PixelInput input
-#if GLSL
-	, out float4 OutColor : SV_Target0
-#endif
-	)
+void PS_Depth(PixelInput input)
 {
 #if MATERIAL_MASKED
 	// Perform per pixel clipping if material requries it
@@ -778,8 +456,6 @@ void PS_Depth(PixelInput input
 	Material material = GetMaterialPS(materialInput);
 	clip(material.Mask - MATERIAL_MASK_THRESHOLD);
 #endif
-
-#if GLSL
-	OutColor = 0;
-#endif
 }
+
+@9
@@ -0,0 +1,246 @@
+// File generated by Flax Materials Editor
+// Version: @0
+
+#define MATERIAL 1
+@3
+
+#include "./Flax/Common.hlsl"
+#include "./Flax/MaterialCommon.hlsl"
+#include "./Flax/GBufferCommon.hlsl"
+@7
+
+// Primary constant buffer (with additional material parameters)
+META_CB_BEGIN(0, Data)
+float4x4 ViewProjectionMatrix;
+float4x4 InverseViewProjectionMatrix;
+float4x4 ViewMatrix;
+float4x4 WorldMatrix;
+float4x4 WorldMatrixInverseTransposed;
+float3 ViewPos;
+float ViewFar;
+float3 ViewDir;
+float TimeParam;
+float4 ViewInfo;
+float4 ScreenSize;
+float3 GridSize;
+float PerInstanceRandom;
+float Dummy0;
+float VolumetricFogMaxDistance;
+int ParticleStride;
+int ParticleIndex;
+@1META_CB_END
+
+// Particles attributes buffer
+ByteAddressBuffer ParticlesData : register(t0);
+
+// Shader resources
+@2
+// Material properties generation input
+struct MaterialInput
+{
+	float3 WorldPosition;
+	float TwoSidedSign;
+	float2 TexCoord;
+	uint ParticleIndex;
+#if USE_VERTEX_COLOR
+	half4 VertexColor;
+#endif
+	float3x3 TBN;
+	float4 SvPosition;
+	float3 PreSkinnedPosition;
+	float3 PreSkinnedNormal;
+	float3 InstanceOrigin;
+	float InstanceParams;
+#if USE_CUSTOM_VERTEX_INTERPOLATORS
+	float4 CustomVSToPS[CUSTOM_VERTEX_INTERPOLATORS_COUNT];
+#endif
+};
+
+#define GetInstanceTransform(input) WorldMatrix;
+
+// Removes the scale vector from the local to world transformation matrix (supports instancing)
+float3x3 RemoveScaleFromLocalToWorld(float3x3 localToWorld)
+{
+	// Extract per axis scales from localToWorld transform
+	float scaleX = length(localToWorld[0]);
+	float scaleY = length(localToWorld[1]);
+	float scaleZ = length(localToWorld[2]);
+	float3 invScale = float3(
+		scaleX > 0.00001f ? 1.0f / scaleX : 0.0f,
+		scaleY > 0.00001f ? 1.0f / scaleY : 0.0f,
+		scaleZ > 0.00001f ? 1.0f / scaleZ : 0.0f);
+	localToWorld[0] *= invScale.x;
+	localToWorld[1] *= invScale.y;
+	localToWorld[2] *= invScale.z;
+	return localToWorld;
+}
+
+// Transforms a vector from tangent space to world space
+float3 TransformTangentVectorToWorld(MaterialInput input, float3 tangentVector)
+{
+	return mul(tangentVector, input.TBN);
+}
+
+// Transforms a vector from world space to tangent space
+float3 TransformWorldVectorToTangent(MaterialInput input, float3 worldVector)
+{
+	return mul(input.TBN, worldVector);
+}
+
+// Transforms a vector from world space to view space
+float3 TransformWorldVectorToView(MaterialInput input, float3 worldVector)
+{
+	return mul(worldVector, (float3x3)ViewMatrix);
+}
+
+// Transforms a vector from view space to world space
+float3 TransformViewVectorToWorld(MaterialInput input, float3 viewVector)
+{
+	return mul((float3x3)ViewMatrix, viewVector);
+}
+
+// Transforms a vector from local space to world space
+float3 TransformLocalVectorToWorld(MaterialInput input, float3 localVector)
+{
+	float3x3 localToWorld = (float3x3)GetInstanceTransform(input);
+	//localToWorld = RemoveScaleFromLocalToWorld(localToWorld);
+	return mul(localVector, localToWorld);
+}
+
+// Transforms a vector from local space to world space
+float3 TransformWorldVectorToLocal(MaterialInput input, float3 worldVector)
+{
+	float3x3 localToWorld = (float3x3)GetInstanceTransform(input);
+	//localToWorld = RemoveScaleFromLocalToWorld(localToWorld);
+	return mul(localToWorld, worldVector);
+}
+
+// Gets the current object position (supports instancing)
+float3 GetObjectPosition(MaterialInput input)
+{
+	return input.InstanceOrigin.xyz;
+}
+
+// Gets the current object size
+float3 GetObjectSize(MaterialInput input)
+{
+	return float3(1, 1, 1);
+}
+
+// Get the current object random value (supports instancing)
+float GetPerInstanceRandom(MaterialInput input)
+{
+	return input.InstanceParams;
+}
+
+// Get the current object LOD transition dither factor (supports instancing)
+float GetLODDitherFactor(MaterialInput input)
+{
+	return 0;
+}
+
+// Gets the interpolated vertex color (in linear space)
+float4 GetVertexColor(MaterialInput input)
+{
+	return 1;
+}
+
+uint GetParticleUint(uint particleIndex, int offset)
+{
+	return ParticlesData.Load(particleIndex * ParticleStride + offset);
+}
+
+int GetParticleInt(uint particleIndex, int offset)
+{
+	return asint(ParticlesData.Load(particleIndex * ParticleStride + offset));
+}
+
+float GetParticleFloat(uint particleIndex, int offset)
+{
+	return asfloat(ParticlesData.Load(particleIndex * ParticleStride + offset));
+}
+
+float2 GetParticleVec2(uint particleIndex, int offset)
+{
+	return asfloat(ParticlesData.Load2(particleIndex * ParticleStride + offset));
+}
+
+float3 GetParticleVec3(uint particleIndex, int offset)
+{
+	return asfloat(ParticlesData.Load3(particleIndex * ParticleStride + offset));
+}
+
+float4 GetParticleVec4(uint particleIndex, int offset)
+{
+	return asfloat(ParticlesData.Load4(particleIndex * ParticleStride + offset));
+}
+
+float3 TransformParticlePosition(float3 input)
+{
+	return mul(float4(input, 1.0f), WorldMatrix).xyz;
+}
+
+float3 TransformParticleVector(float3 input)
+{
+	return mul(float4(input, 0.0f), WorldMatrixInverseTransposed).xyz;
+}
+
+@8
+
+// Get material properties function (for vertex shader)
+Material GetMaterialVS(MaterialInput input)
+{
+@5
+}
+
+// Get material properties function (for domain shader)
+Material GetMaterialDS(MaterialInput input)
+{
+@6
+}
+
+// Get material properties function (for pixel shader)
+Material GetMaterialPS(MaterialInput input)
+{
+@4
+}
+
+// Pixel Shader function for Volumetric Fog material injection (local fog)
+META_PS(true, FEATURE_LEVEL_SM5)
+void PS_VolumetricFog(Quad_GS2PS input, out float4 VBufferA : SV_Target0, out float4 VBufferB : SV_Target1)
+{
+	uint3 gridCoordinate = uint3(input.Vertex.Position.xy, input.LayerIndex);
+	float3 cellOffset = 0.5f;
+	float2 volumeUV = (gridCoordinate.xy + cellOffset.xy) / GridSize.xy;
+	float zSlice = gridCoordinate.z + cellOffset.z;
+	float sceneDepth = (zSlice / GridSize.z) * VolumetricFogMaxDistance / ViewFar;
+	float deviceDepth = (ViewInfo.w / sceneDepth) + ViewInfo.z;
+	float4 clipPos = float4(volumeUV * float2(2.0, -2.0) + float2(-1.0, 1.0), deviceDepth, 1.0);
+	float4 wsPos = mul(clipPos, InverseViewProjectionMatrix);
+	float3 positionWS = wsPos.xyz / wsPos.w;
+
+	// Get material parameters
+	MaterialInput materialInput = (MaterialInput)0;
+	materialInput.WorldPosition = positionWS;
+	materialInput.TexCoord = input.Vertex.TexCoord;
+	materialInput.ParticleIndex = ParticleIndex;
+	materialInput.TBN = float3x3(float3(1, 0, 0), float3(0, 1, 0), float3(0, 0, 1));
+	materialInput.TwoSidedSign = 1.0f;
+	materialInput.InstanceOrigin = WorldMatrix[3].xyz;
+	materialInput.InstanceParams = PerInstanceRandom;
+	materialInput.SvPosition = clipPos;
+	Material material = GetMaterialPS(materialInput);
+
+	// Compute fog properties
+	float3 albedo = material.Color;
+	float extinction = material.Opacity * material.Mask * 0.001f;
+	float3 emission = material.Emissive;
+	float3 scattering = albedo * extinction;
+	float absorption = max(0.0f, extinction - Luminance(scattering));
+
+	// Write fog properties
+	VBufferA = float4(scattering, absorption);
+	VBufferB = float4(emission, 0);
+}
+
+@9
@@ -0,0 +1,23 @@
+%copyright%
+#pragma once
+
+#include "Engine/Core/ISerializable.h"
+#include "Engine/Core/Types/BaseTypes.h"
+#include "Engine/Content/Assets/Model.h"
+#include "Engine/Scripting/ScriptingType.h"
+
+/// <summary>
+/// %class% Json Asset. 
+/// </summary>
+API_CLASS() class %module%%class% : public ISerializable
+{
+    API_AUTO_SERIALIZATION();
+    DECLARE_SCRIPTING_TYPE_NO_SPAWN(%class%);
+public:
+	// Custom float value.
+    API_FIELD(Attributes = "Range(0, 20), EditorOrder(0), EditorDisplay(\"Data\")") 
+    float FloatValue = 20.0f;
+	// Custom vector data.
+    API_FIELD(Attributes = "EditorOrder(1), EditorDisplay(\"Data\")")
+    Vector3 Vector3Value = Vector3(0.1f);
+};
@@ -0,0 +1,8 @@
+%copyright%
+#include "%filename%.h"
+#include "Engine/Core/Log.h"
+
+void %class%::RunNativeAction(Vector4 data)
+{
+    LOG(Warning, "Data in RunNativeAction: {0}", data);
+}
@@ -0,0 +1,20 @@
+%copyright%
+#pragma once
+
+#include "Engine/Scripting/Script.h"
+#include "Engine/Core/Math/Vector4.h"
+
+/// <summary>
+/// %class% Function Library
+/// </summary>
+API_CLASS(Static) class %module%%class% 
+{
+    DECLARE_SCRIPTING_TYPE_MINIMAL(%class%);
+public:
+
+    /// <summary>
+    /// Logs the function parameter natively.
+    /// </summary>
+    /// <param name="data">Data to pass to native code</param>
+    API_FUNCTION() static void RunNativeAction(Vector4 data);
+};
@@ -4,23 +4,30 @@ using FlaxEngine;

 namespace %namespace%
 {
+    /// <summary>
+    /// %class% Script.
+    /// </summary>
    public class %class% : Script
    {
+        /// <inheritdoc/>
        public override void OnStart()
        {
            // Here you can add code that needs to be called when script is created, just before the first game update
        }
        
+        /// <inheritdoc/>
        public override void OnEnable()
        {
            // Here you can add code that needs to be called when script is enabled (eg. register for events)
        }

+        /// <inheritdoc/>
        public override void OnDisable()
        {
            // Here you can add code that needs to be called when script is disabled (eg. unregister from events)
        }

+        /// <inheritdoc/>
        public override void OnUpdate()
        {
            // Here you can add code that needs to be called every frame
@@ -5,6 +5,7 @@

 API_CLASS() class %module%%class% : public Script
 {
+API_AUTO_SERIALIZATION();
 DECLARE_SCRIPTING_TYPE(%class%);

    // [Script]
@@ -0,0 +1,15 @@
+## Mono
+
+Custom fork: [https://github.com/FlaxEngine/mono](https://github.com/FlaxEngine/mono) with custom features for C# assemblies hot-reloading at runtime without domain unload (more: [https://flaxengine.com/blog/flax-facts-16-scripts-hot-reload/](https://flaxengine.com/blog/flax-facts-16-scripts-hot-reload/)).
+
+### Notes
+
+Some useful notes and tips for devs:
+* Use `-monolog` to print Mono logs to Flax logs
+* When working with mono fork set `localRepoPath` to local repo location in `Source\Tools\Flax.Build\Deps\Dependencies\mono.cs`
+* To update mono deps when developing/updating use `.\Development\Scripts\Windows\CallBuildTool.bat -log -ReBuildDeps -verbose -depsToBuild=mono -platform=Windows`, then build engine and run it
+* `MONO_GC_DEBUG=check-remset-consistency` - it will do additional checks at each collection to see if there are any missing write barriers
+* `MONO_GC_DEBUG=nursery-canaries` - it might catch some buffer overflows in case of problems in code.
+* `MONO_GC_DEBUG=<log-level>:<log-file>` - will print GC debug to the log file (eg. `4:sgen-gc`).
+* Methods `mono_custom_attrs_from_property` and `mono_custom_attrs_get_attr` are internally cached
+* If C++ mono call a method in c# that will throw an error, error will be handled but, not completly. Calling relase domain will return random `Access memory violation`. First search for error in c# code. No workaround yet.
@@ -3,6 +3,12 @@

 set -e

+testfilesize=$(wc -c < 'Source/Logo.png')
+if [ $testfilesize -le 1000 ]; then
+    echo "CallBuildTool ERROR: Repository was not cloned using Git LFS" 1>&2
+	exit 1
+fi
+
 # Compile the build tool.
 xbuild /nologo /verbosity:quiet "Source/Tools/Flax.Build/Flax.Build.csproj" /property:Configuration=Release /property:Platform=AnyCPU /target:Build

@@ -2,93 +2,55 @@

 rem Copyright (c) 2012-2020 Wojciech Figat. All rights reserved.

-rem Make sure the batch file exists in the root folder.
-if not exist "Development\Scripts\Windows\GetMSBuildPath.bat" goto Error_BatchFileInWrongLocation
+if not exist "Development\Scripts\Windows\GetMSBuildPath.bat" goto Error_InvalidLocation
+
+for %%I in (Source\Logo.png) do if %%~zI LSS 2000 (
+	goto Error_MissingLFS
+)

-rem Get the path to MSBuild executable.
 call "Development\Scripts\Windows\GetMSBuildPath.bat"
 if errorlevel 1 goto Error_NoVisualStudioEnvironment

-rem If using VS2017, check that NuGet package manager is installed.
-if not exist "%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" goto NoVsWhere
-
-set MSBUILD_15_EXE=
+if not exist "%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" goto Compile
 for /f "delims=" %%i in ('"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere" -latest -products * -requires Microsoft.Component.MSBuild -property installationPath') do (
 	for %%j in (15.0, Current) do (
 		if exist "%%i\MSBuild\%%j\Bin\MSBuild.exe" (
-			set MSBUILD_15_EXE="%%i\MSBuild\%%j\Bin\MSBuild.exe"
-			goto FoundMsBuild15
+			set MSBUILD_PATH="%%i\MSBuild\%%j\Bin\MSBuild.exe"
+			goto Compile
 		)
 	)
 )
-:FoundMsBuild15

-set MSBUILD_15_EXE_WITH_NUGET=
-for /f "delims=" %%i in ('"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere" -latest -products * -requires Microsoft.Component.MSBuild -requires Microsoft.VisualStudio.Component.NuGet -property installationPath') do (
-	if exist "%%i\MSBuild\15.0\Bin\MSBuild.exe" (
-		set MSBUILD_15_EXE_WITH_NUGET="%%i\MSBuild\15.0\Bin\MSBuild.exe"
-		goto FoundMsBuild15WithNuget
-	)
-)
-:FoundMsBuild15WithNuget
-
-if not [%MSBUILD_15_EXE%] == [] (
-	set MSBUILD_EXE=%MSBUILD_15_EXE%
-	goto NoVsWhere
-)
-
-if not [%MSBUILD_EXE%] == [%MSBUILD_15_EXE_WITH_NUGET%] goto Error_RequireNugetPackageManager
-
-:NoVsWhere
-
-rem Check to see if the build tool source files have changed. Some can be included conditionally based on NDA access.
+:Compile
 md Cache\Intermediate >nul 2>nul
 dir /s /b Source\Tools\Flax.Build\*.cs >Cache\Intermediate\Flax.Build.Files.txt
 fc /b Cache\Intermediate\Build\Flax.Build.Files.txt Cache\Intermediate\Build\Flax.Build.PrevFiles.txt >nul 2>nul
 if not errorlevel 1 goto SkipClean
-copy /y Cache\Intermediate\Build\Flax.Build.Files.txt Cache\Intermediate\Build\Flax.Build.PrevFiles.txt >nul
-%MSBUILD_EXE% /nologo /verbosity:quiet Source\Tools\Flax.Build\Flax.Build.csproj /property:Configuration=Release /property:Platform=AnyCPU /target:Clean
-:SkipClean
-%MSBUILD_EXE% /nologo /verbosity:quiet Source\Tools\Flax.Build\Flax.Build.csproj /property:Configuration=Release /property:Platform=AnyCPU /target:Build
-if errorlevel 1 goto Error_CompileFailed

-rem Run the build tool using the provided arguments.
+copy /y Cache\Intermediate\Build\Flax.Build.Files.txt Cache\Intermediate\Build\Flax.Build.PrevFiles.txt >nul
+%MSBUILD_PATH% /nologo /verbosity:quiet Source\Tools\Flax.Build\Flax.Build.csproj /property:Configuration=Release /property:Platform=AnyCPU /target:Clean
+:SkipClean
+%MSBUILD_PATH% /nologo /verbosity:quiet Source\Tools\Flax.Build\Flax.Build.csproj /property:Configuration=Release /property:Platform=AnyCPU /target:Build
+if errorlevel 1 goto Error_CompilationFailed
+
 Binaries\Tools\Flax.Build.exe %*
 if errorlevel 1 goto Error_FlaxBuildFailed
-
-rem Done.
 exit /B 0

-:Error_BatchFileInWrongLocation
-echo.
-echo CallBuildTool ERROR: The batch file does not appear to be located in the root directory. This script must be run from within that directory.
-echo.
+:Error_MissingLFS
+echo CallBuildTool ERROR: Repository was not cloned using Git LFS
+goto Exit
+:Error_InvalidLocation
+echo CallBuildTool ERROR: The script is in invalid directory.
 goto Exit
-
 :Error_NoVisualStudioEnvironment
-echo.
-echo CallBuildTool ERROR: We couldn't find a valid installation of Visual Studio. This program requires Visual Studio 2015. Please check that you have Visual Studio installed, then verify that the HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\14.0\InstallDir (or HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\14.0\InstallDir on 32-bit machines) registry value is set.  Visual Studio configures this value when it is installed, and this program expects it to be set to the '\Common7\IDE\' sub-folder under a valid Visual Studio installation directory.
-echo.
+echo CallBuildTool ERROR: Missing Visual Studio 2015 or newer.
 goto Exit
-
-:Error_RequireNugetPackageManager
-echo.
-echo CallBuildTool ERROR: NuGet Package Manager is requried to be installed to use %MSBUILD_EXE%. Please run the Visual Studio Installer and add it from the individual components list (in the 'Code Tools' category).
-echo.
-goto Exit
-
-:Error_CompileFailed
-echo.
+:Error_CompilationFailed
 echo CallBuildTool ERROR: Failed to compile Flax.Build project.
-echo.
 goto Exit
-
 :Error_FlaxBuildFailed
-echo.
 echo CallBuildTool ERROR: Flax.Build tool failed.
-echo.
 goto Exit
-
 :Exit
-rem Exit with error.
 exit /B 1
@@ -2,72 +2,57 @@

 rem Copyright (c) 2012-2020 Wojciech Figat. All rights reserved.

-set MSBUILD_EXE=
+set MSBUILD_PATH=

-rem Try to get the MSBuild 15 path using vswhere (see https://github.com/Microsoft/vswhere).
-if not exist "%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" goto no_vswhere
+if not exist "%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" goto VsWhereNotFound
 for /f "delims=" %%i in ('"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere" -latest -products * -requires Microsoft.Component.MSBuild -property installationPath') do (
 	if exist "%%i\MSBuild\15.0\Bin\MSBuild.exe" (
-		set MSBUILD_EXE="%%i\MSBuild\15.0\Bin\MSBuild.exe"
-		goto Succeeded
+		set MSBUILD_PATH="%%i\MSBuild\15.0\Bin\MSBuild.exe"
+		goto End
 	)
 )
-:no_vswhere
+:VsWhereNotFound

-rem Check for MSBuild 15. This is installed alongside Visual Studio 2017, so we get the path relative to that.
-call :ReadInstallPath Microsoft\VisualStudio\SxS\VS7 15.0 MSBuild\15.0\bin\MSBuild.exe
-if not errorlevel 1 goto Succeeded
-
-rem Try to get the MSBuild 14.0 path directly (see https://msdn.microsoft.com/en-us/library/hh162058(v=vs.120).aspx).
 if exist "%ProgramFiles(x86)%\MSBuild\14.0\bin\MSBuild.exe" (
-	set MSBUILD_EXE="%ProgramFiles(x86)%\MSBuild\14.0\bin\MSBuild.exe"
-	goto Succeeded
+	set MSBUILD_PATH="%ProgramFiles(x86)%\MSBuild\14.0\bin\MSBuild.exe"
+	goto End
 )

-rem Try to get the MSBuild 14.0 path from the registry.
-call :ReadInstallPath Microsoft\MSBuild\ToolsVersions\14.0 MSBuildToolsPath MSBuild.exe
-if not errorlevel 1 goto Succeeded
+call :GetInstallPath Microsoft\VisualStudio\SxS\VS7 15.0 MSBuild\15.0\bin\MSBuild.exe
+if not errorlevel 1 goto End
+call :GetInstallPath Microsoft\MSBuild\ToolsVersions\14.0 MSBuildToolsPath MSBuild.exe
+if not errorlevel 1 goto End
+call :GetInstallPath Microsoft\MSBuild\ToolsVersions\12.0 MSBuildToolsPath MSBuild.exe
+if not errorlevel 1 goto End
+call :GetInstallPath Microsoft\MSBuild\ToolsVersions\4.0 MSBuildToolsPath MSBuild.exe
+if not errorlevel 1 goto End

-rem Check for older versions of MSBuild. These are registered as separate versions in the registry.
-call :ReadInstallPath Microsoft\MSBuild\ToolsVersions\12.0 MSBuildToolsPath MSBuild.exe
-if not errorlevel 1 goto Succeeded
-call :ReadInstallPath Microsoft\MSBuild\ToolsVersions\4.0 MSBuildToolsPath MSBuild.exe
-if not errorlevel 1 goto Succeeded
-
-rem Searching failed.
 exit /B 1
-
-rem Searching done!
-:Succeeded
+:End
 exit /B 0

-rem Subroutine to query the registry under HKCU/HKLM Win32/Wow64 software registry keys for a certain install directory.
-rem Arguments: 
-rem      %1 = Registry path under the 'SOFTWARE' registry key
-rem      %2 = Value name
-rem      %3 = Relative path under this directory to look for an installed executable.
-:ReadInstallPath
+:GetInstallPath
 for /f "tokens=2,*" %%A in ('REG.exe query HKCU\SOFTWARE\%1 /v %2 2^>Nul') do (
 	if exist "%%B%%3" (
-		set MSBUILD_EXE="%%B%3"
+		set MSBUILD_PATH="%%B%3"
 		exit /B 0
 	)
 )
 for /f "tokens=2,*" %%A in ('REG.exe query HKLM\SOFTWARE\%1 /v %2 2^>Nul') do (
 	if exist "%%B%3" (
-		set MSBUILD_EXE="%%B%3"
+		set MSBUILD_PATH="%%B%3"
 		exit /B 0
 	)
 )
 for /f "tokens=2,*" %%A in ('REG.exe query HKCU\SOFTWARE\Wow6432Node\%1 /v %2 2^>Nul') do (
 	if exist "%%B%%3" (
-		set MSBUILD_EXE="%%B%3"
+		set MSBUILD_PATH="%%B%3"
 		exit /B 0
 	)
 )
 for /f "tokens=2,*" %%A in ('REG.exe query HKLM\SOFTWARE\Wow6432Node\%1 /v %2 2^>Nul') do (
 	if exist "%%B%3" (
-		set MSBUILD_EXE="%%B%3"
+		set MSBUILD_PATH="%%B%3"
 		exit /B 0
 	)
 )
@@ -2,11 +2,11 @@
  "Name": "Flax",
  "Version": {
    "Major": 1,
-    "Minor": 0,
-    "Build": 6214
+    "Minor": 2,
+    "Build": 6224
  },
  "Company": "Flax",
-  "Copyright": "Copyright (c) 2012-2020 Wojciech Figat. All rights reserved.",
+  "Copyright": "Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.",
  "GameTarget": "FlaxGame",
  "EditorTarget": "FlaxEditor"
 }
@@ -234,6 +234,7 @@
 	<s:String x:Key="/Default/PatternsAndTemplates/Todo/TodoPatterns/=EEA05B0ED8200E4BA9D2D3F1052EBFFD/Name/@EntryValue">Deprecated</s:String>
 	<s:String x:Key="/Default/PatternsAndTemplates/Todo/TodoPatterns/=EEA05B0ED8200E4BA9D2D3F1052EBFFD/Pattern/@EntryValue">(?&lt;=\W|^)(?&lt;TAG&gt;\[Deprecated)(\W|$)(.*)</s:String>
 	<s:String x:Key="/Default/PatternsAndTemplates/Todo/TodoPatterns/=EEA05B0ED8200E4BA9D2D3F1052EBFFD/TodoIconStyle/@EntryValue">Normal</s:String>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Ackermann/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=analytics/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Antialiasing/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=backbuffer/@EntryIndexedValue">True</s:Boolean>
@@ -6,34 +6,19 @@ setlocal
 pushd
 echo Generating Flax Engine project files...

-rem Make sure the batch file exists in the root folder.
-if not exist "%~dp0\Source" goto Error_BatchFileInWrongLocation
-if not exist "Development\Scripts\Windows\CallBuildTool.bat" goto Error_BatchFileInWrongLocation
-
 rem Run Flax.Build to generate Visual Studio solution and project files (also pass the arguments)
 call "Development\Scripts\Windows\CallBuildTool.bat" -genproject %*
-if errorlevel 1 goto Error_BuildToolFailed
+if errorlevel 1 goto BuildToolFailed

-rem Done.
 popd
 echo Done!
 exit /B 0

-:Error_BatchFileInWrongLocation
-echo.
-echo The batch file does not appear to be located in the root directory. This script must be run from within that directory.
-echo.
-pause
-goto Exit
-
-:Error_BuildToolFailed
-echo.
+:BuildToolFailed
 echo Flax.Build tool failed.
-echo.
 pause
 goto Exit

 :Exit
-rem Restore original directory before exit.
 popd
 exit /B 1
@@ -6,32 +6,18 @@ setlocal
 pushd
 echo Performing the full package...

-rem Make sure the batch file exists in the root folder.
-if not exist "%~dp0\Source" goto Error_BatchFileInWrongLocation
-if not exist "Development\Scripts\Windows\CallBuildTool.bat" goto Error_BatchFileInWrongLocation
-
 rem Run the build tool.
 call "Development\Scripts\Windows\CallBuildTool.bat" -deploy -deployEditor -deployPlatforms -verbose -log -logFile="Cache\Intermediate\PackageLog.txt" %*
-if errorlevel 1 goto Error_BuildToolFailed
+if errorlevel 1 goto BuildToolFailed

-rem Done.
 popd
 echo Done!
 exit /B 0

-:Error_BatchFileInWrongLocation
-echo.
-echo The batch file does not appear to be located in the root directory. This script must be run from within that directory.
-echo.
-goto Exit
-
-:Error_BuildToolFailed
-echo.
+:BuildToolFailed
 echo Flax.Build tool failed.
-echo.
 goto Exit

 :Exit
-rem Restore original directory before exit.
 popd
 exit /B 1
@@ -6,32 +6,18 @@ setlocal
 pushd
 echo Building and packaging Flax Editor...

-rem Make sure the batch file exists in the root folder.
-if not exist "%~dp0\Source" goto Error_BatchFileInWrongLocation
-if not exist "Development\Scripts\Windows\CallBuildTool.bat" goto Error_BatchFileInWrongLocation
-
-rem Run Flax.Build to generate Visual Studio solution and project files (also pass the arguments)
+rem Run the build tool.
 call "Development\Scripts\Windows\CallBuildTool.bat" -deploy -deployEditor -verbose -log -logFile="Cache\Intermediate\PackageLog.txt" %*
-if errorlevel 1 goto Error_BuildToolFailed
+if errorlevel 1 goto BuildToolFailed

-rem Done.
 popd
 echo Done!
 exit /B 0

-:Error_BatchFileInWrongLocation
-echo.
-echo The batch file does not appear to be located in the root directory. This script must be run from within that directory.
-echo.
-goto Exit
-
-:Error_BuildToolFailed
-echo.
+:BuildToolFailed
 echo Flax.Build tool failed.
-echo.
 goto Exit

 :Exit
-rem Restore original directory before exit.
 popd
 exit /B 1
@@ -0,0 +1,12 @@
+#!/bin/sh
+# Copyright (c) 2012-2020 Wojciech Figat. All rights reserved.
+
+set -e
+
+echo Building and packaging Flax Editor...
+
+# Change the path to the script root
+cd "`dirname "$0"`"
+
+# Run Flax.Build (also pass the arguments)
+bash ./Development/Scripts/Linux/CallBuildTool.sh --deploy --deployEditor --verbose --log --logFile="Cache/Intermediate/PackageLog.txt" "$@"
@@ -6,32 +6,18 @@ setlocal
 pushd
 echo Building and packaging platforms data...

-rem Make sure the batch file exists in the root folder.
-if not exist "%~dp0\Source" goto Error_BatchFileInWrongLocation
-if not exist "Development\Scripts\Windows\CallBuildTool.bat" goto Error_BatchFileInWrongLocation
-
-rem Run Flax.Build to generate Visual Studio solution and project files (also pass the arguments)
+rem Run the build tool.
 call "Development\Scripts\Windows\CallBuildTool.bat" -deploy -deployPlatforms -verbose -log -logFile="Cache\Intermediate\PackageLog.txt" %*
-if errorlevel 1 goto Error_BuildToolFailed
+if errorlevel 1 goto BuildToolFailed

-rem Done.
 popd
 echo Done!
 exit /B 0

-:Error_BatchFileInWrongLocation
-echo.
-echo The batch file does not appear to be located in the root directory. This script must be run from within that directory.
-echo.
-goto Exit
-
-:Error_BuildToolFailed
-echo.
+:BuildToolFailed
 echo Flax.Build tool failed.
-echo.
 goto Exit

 :Exit
-rem Restore original directory before exit.
 popd
 exit /B 1
--- a/Show More
+++ b/Show More