Increase maximum window width limit to 8k

3cf3f58db1

.github/workflows/build_linux.todo

@@ -1,19 +0,0 @@
-name: Build Linux
-on: [push, pull_request]
-
-jobs:
-
-  # Game
-  game-linux:
-    name: Game (Linux, Release 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: Build
-      run: |
-        ./Development/Scripts/Linux/CallBuildTool.sh -build -log -arch=x64 -platform=Linux -configuration=Release -buildtargets=FlaxGame

.github/workflows/build_linux.yml

@@ -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

.github/workflows/build_linux_sources.list

@@ -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

.github/workflows/cd.yml

@@ -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

.gitignore

@@ -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
+

CONTRIBUTING.md

@@ -32,3 +32,19 @@ Go check out our [Trello](https://trello.com/b/NQjLXRCP/flax-roadmap).
 
 
 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`

Content/Editor/MaterialTemplates/Decal.shader

@@ -108,15 +108,14 @@ float4 GetVertexColor(MaterialInput input)
 	return 1;
 }
 
+@8
+
 // Get material properties function (for pixel shader)
 Material GetMaterialPS(MaterialInput input)
 {
 @4
 }
 
-// Fix line for errors/warnings for shader code from template
-#line 1000
-
 // Input macro specified by the material: DECAL_BLEND_MODE
 
 #define DECAL_BLEND_MODE_TRANSLUCENT 0
@@ -195,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

Content/Editor/MaterialTemplates/Deformable.shader

@@ -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

Content/Editor/MaterialTemplates/Features/DeferredShading.hlsl

@@ -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
+}

Content/Editor/MaterialTemplates/Features/Distortion.hlsl

@@ -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

Content/Editor/MaterialTemplates/Features/ForwardShading.hlsl

@@ -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;
+}

Content/Editor/MaterialTemplates/Features/Lightmap.hlsl

@@ -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

Content/Editor/MaterialTemplates/Features/MotionVectors.hlsl

@@ -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);
+}

Content/Editor/MaterialTemplates/Features/Tessellation.hlsl

@@ -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

Content/Editor/MaterialTemplates/GUI.shader

@@ -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,9 +198,6 @@ Material GetMaterialPS(MaterialInput input)
 @4
 }
 
-// Fix line for errors/warnings for shader code from template
-#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)
@@ -257,3 +255,5 @@ float4 PS_GUI(PixelInput input) : SV_Target0
 
 	return float4(material.Emissive, material.Opacity);
 }
+
+@9

Content/Editor/MaterialTemplates/Particle.shader

@@ -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,9 +298,6 @@ Material GetMaterialPS(MaterialInput input)
 @4
 }
 
-// Fix line for errors/warnings for shader code from template
-#line 1000
-
 // Calculates the transform matrix from mesh tangent space to local space
 half3x3 CalcTangentToLocal(ModelInput input)
 {
@@ -712,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;
-
-	// 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
-
 // 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);
@@ -860,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

Content/Editor/MaterialTemplates/PostProcess.shader

@@ -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,15 +128,14 @@ float4 GetVertexColor(MaterialInput input)
 	return 1;
 }
 
+@8
+
 // Get material properties function (for pixel shader)
 Material GetMaterialPS(MaterialInput input)
 {
 @4
 }
 
-// Fix line for errors/warnings for shader code from template
-#line 1000
-
 // Pixel Shader function for PostFx materials rendering
 META_PS(true, FEATURE_LEVEL_ES2)
 float4 PS_PostFx(PixelInput input) : SV_Target0
@@ -147,3 +146,5 @@ float4 PS_PostFx(PixelInput input) : SV_Target0
 
 	return float4(material.Emissive, material.Opacity);
 }
+
+@9

Content/Editor/MaterialTemplates/Surface.shader

@@ -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

Content/Editor/MaterialTemplates/Terrain.shader

@@ -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,9 +264,6 @@ Material GetMaterialPS(MaterialInput input)
 @4
 }
 
-// Fix line for errors/warnings for shader code from template
-#line 1000
-
 // Calculates LOD value (with fractional part for blending)
 float CalcLOD(float2 xy, float4 morph)
 {
@@ -336,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);
@@ -353,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
@@ -364,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)
@@ -419,356 +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
-	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
@@ -776,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

Content/Editor/MaterialTemplates/VolumeParticle.shader

@@ -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

Content/Editor/Scripting/CppAssetTemplate.h

@@ -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);
+};

Content/Editor/Scripting/CppStaticClassTemplate.cpp

@@ -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);
+}

Content/Editor/Scripting/CppStaticClassTemplate.h

@@ -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);
+};

Content/Editor/Scripting/ScriptTemplate.cs

@@ -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

Content/Editor/Scripting/ScriptTemplate.h

@@ -5,6 +5,7 @@
 
 API_CLASS() class %module%%class% : public Script
 {
+API_AUTO_SERIALIZATION();
 DECLARE_SCRIPTING_TYPE(%class%);
 
     // [Script]

Development/Documentation/mono.md

@@ -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.

Flax.flaxproj

@@ -2,8 +2,8 @@
   "Name": "Flax",
   "Version": {
     "Major": 1,
-    "Minor": 0,
-    "Build": 6216
+    "Minor": 2,
+    "Build": 6224
   },
   "Company": "Flax",
   "Copyright": "Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.",

Flax.sln.DotSettings

@@ -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>

PackageEditor.sh

@@ -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" "$@"

PackagePlatforms.sh

@@ -8,5 +8,5 @@ echo Building and packaging platforms data...
 # Change the path to the script root
 cd "`dirname "$0"`"
 
-# Run Flax.Build to generate project files (also pass the arguments)
+# Run Flax.Build (also pass the arguments)
 bash ./Development/Scripts/Linux/CallBuildTool.sh --deploy --deployPlatforms --verbose --log --logFile="Cache/Intermediate/PackageLog.txt" "$@"

README.md

@@ -34,25 +34,35 @@ Flax Visual Studio extension provides better programming workflow, C# scripts de
 
 * Install Visual Studio 2015 or newer
 * Install Windows 8.1 SDK or newer
-* Install Microsoft Visual C++ 2015.3 v140 toolset for desktop (x86, x64)
+* Install Microsoft Visual C++ 2015 v140 toolset or newer
 * Clone repo (with LFS)
 * Run **GenerateProjectFiles.bat**
 * Open `Flax.sln` and set solution configuration to **Editor.Development** and solution platform to **Win64**
-* Set Flax or FlaxEngine as startup project
+* Set Flax (C++) or FlaxEngine (C#) as startup project
 * Compile Flax project (hit F7 or CTRL+Shift+B)
 * Run Flax (hit F5 key)
 
+---
+
+**Note**
+
+If building on Windows to support Vulkan rendering, first install the Vulkan SDK then  set an environment variable to provide the path to the SDK prior to running GenerateProjectFiles.bat:
+
+    set VULKAN_SDK=C:\VulkanSDK\version\
+
+---
+
 ## Linux
 
 * Install Visual Studio Code
 * Install Mono ([https://www.mono-project.com/download/stable](https://www.mono-project.com/download/stable))
 * Install Git with LFS
-* Install requried packages: `sudo apt-get install nuget autoconf libtool libogg-dev automake build-essential gettext cmake python curl libtool-bin libx11-dev libpulse-dev libasound2-dev libjack-dev portaudio19-dev`
-* Install compiler `sudo apt-get install clang-7 lldb-7 lld-7`
+* Install requried packages: `sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev nuget autoconf libogg-dev automake build-essential gettext cmake python libtool libtool-bin libpulse-dev libasound2-dev libjack-dev portaudio19-dev`
+* Install compiler `sudo apt-get install clang lldb lld` (Clang 6 or newer)
 * Clone repo (with LFS)
-* Run `sudo bash GenerateProjectFiles.sh`
+* Run `./GenerateProjectFiles.sh`
 * Open workspace with Visual Code
-* Build and run
+* Build and run (configuration and task named `Flax|Editor.Linux.Development|x64`)
 
 ## Workspace directory
 

Source/Editor/Analytics/EditorAnalytics.cpp

@@ -8,7 +8,9 @@
 #include "Engine/Core/Math/Vector2.h"
 #include "Engine/Core/Types/DateTime.h"
 #include "Editor/Editor.h"
+#include "Editor/ProjectInfo.h"
 #include "Engine/Engine/EngineService.h"
+#include "Engine/Engine/Globals.h"
 #include "Engine/Graphics/GPUDevice.h"
 #include "Engine/Utilities/StringConverter.h"
 #include "FlaxEngine.Gen.h"
@@ -103,6 +105,8 @@ void EditorAnalytics::StartSession()
             { UA_DOCUMENT_TITLE, 0, "Flax Editor" },
 #if PLATFORM_WINDOWS
             { UA_USER_AGENT, 0, "Windows " FLAXENGINE_VERSION_TEXT },
+#elif PLATFORM_LINUX
+            { UA_USER_AGENT, 0, "Linux " FLAXENGINE_VERSION_TEXT },
 #else
 #error "Unknown platform"
 #endif

Source/Editor/Analytics/EditorAnalyticsController.cpp

@@ -7,7 +7,8 @@
 
 void RegisterGameCookingStart(GameCooker::EventType type)
 {
-    auto platform = ToString(GameCooker::GetCurrentData().Platform);
+    auto& data = *GameCooker::GetCurrentData();
+    auto platform = ToString(data.Platform);
     if (type == GameCooker::EventType::BuildStarted)
     {
         EditorAnalytics::SendEvent("Actions", "GameCooker.Start", platform);

Source/Editor/Content/AssetItemConverter.cs

@@ -26,8 +26,7 @@ namespace FlaxEditor.Content
         {
             if (reader.TokenType == JsonToken.String)
             {
-                Guid id;
-                FlaxEngine.Json.JsonSerializer.ParseID((string)reader.Value, out id);
+                FlaxEngine.Json.JsonSerializer.ParseID((string)reader.Value, out Guid id);
                 return Editor.Instance.ContentDatabase.Find(id);
             }
 

Source/Editor/Content/Create/SettingsCreateEntry.cs

@@ -3,6 +3,7 @@
 using System;
 using FlaxEditor.Content.Settings;
 using FlaxEditor.Scripting;
+using FlaxEditor.Windows.Assets;
 using FlaxEngine;
 
 namespace FlaxEditor.Content.Create
@@ -11,87 +12,31 @@ namespace FlaxEditor.Content.Create
     /// Engine settings asset creating handler. Allows to specify type of the settings to create (e.g. <see cref="GameSettings"/>, <see cref="TimeSettings"/>, etc.).
     /// </summary>
     /// <seealso cref="FlaxEditor.Content.Create.CreateFileEntry" />
-    public class SettingsCreateEntry : CreateFileEntry
+    internal class SettingsCreateEntry : CreateFileEntry
     {
         /// <summary>
         /// Types of the settings assets that can be created.
         /// </summary>
-        public enum SettingsTypes
+        internal enum SettingsTypes
         {
-            /// <summary>
-            /// The game settings.
-            /// </summary>
             GameSettings,
-
-            /// <summary>
-            /// The audio settings.
-            /// </summary>
             AudioSettings,
-
-            /// <summary>
-            /// The time settings.
-            /// </summary>
             TimeSettings,
-
-            /// <summary>
-            /// The layers and tags settings.
-            /// </summary>
             LayersAndTagsSettings,
-
-            /// <summary>
-            /// The physics settings.
-            /// </summary>
             PhysicsSettings,
-
-            /// <summary>
-            /// The graphics settings.
-            /// </summary>
             GraphicsSettings,
-
-            /// <summary>
-            /// The navigation settings.
-            /// </summary>
             NavigationSettings,
-
-            /// <summary>
-            /// The build settings.
-            /// </summary>
+            LocalizationSettings,
             BuildSettings,
-
-            /// <summary>
-            /// The input settings.
-            /// </summary>
             InputSettings,
-
-            /// <summary>
-            /// The Windows settings.
-            /// </summary>
+            StreamingSettings,
             WindowsPlatformSettings,
-
-            /// <summary>
-            /// The UWP settings.
-            /// </summary>
             UWPPlatformSettings,
-
-            /// <summary>
-            /// The Linux settings.
-            /// </summary>
             LinuxPlatformSettings,
-
-            /// <summary>
-            /// The PS4 settings
-            /// </summary>
             PS4PlatformSettings,
-
-            /// <summary>
-            /// The Xbox Scarlett settings
-            /// </summary>
             XboxScarlettPlatformSettings,
-
-            /// <summary>
-            /// The Android settings
-            /// </summary>
             AndroidPlatformSettings,
+            SwitchPlatformSettings,
         }
 
         private static readonly Type[] _types =
@@ -103,20 +48,20 @@ namespace FlaxEditor.Content.Create
             typeof(PhysicsSettings),
             typeof(GraphicsSettings),
             typeof(NavigationSettings),
+            typeof(LocalizationSettings),
             typeof(BuildSettings),
             typeof(InputSettings),
+            typeof(StreamingSettings),
             typeof(WindowsPlatformSettings),
             typeof(UWPPlatformSettings),
             typeof(LinuxPlatformSettings),
             TypeUtils.GetManagedType(GameSettings.PS4PlatformSettingsTypename),
             TypeUtils.GetManagedType(GameSettings.XboxScarlettPlatformSettingsTypename),
             typeof(AndroidPlatformSettings),
+            TypeUtils.GetManagedType(GameSettings.SwitchPlatformSettingsTypename),
         };
 
-        /// <summary>
-        /// The create options.
-        /// </summary>
-        public class Options
+        internal class Options
         {
             /// <summary>
             /// The type.
@@ -150,7 +95,134 @@ namespace FlaxEditor.Content.Create
                 return true;
             }
             var data = Activator.CreateInstance(type);
-            return Editor.SaveJsonAsset(ResultUrl, data);
+            if (Editor.SaveJsonAsset(ResultUrl, data))
+                return true;
+
+            // Automatic settings linking to game settings for easier usage
+            var gameSettingsItem = Editor.Instance.ContentDatabase.Game.Content.Folder.FindChild(GameSettings.GameSettingsAssetPath) as JsonAssetItem;
+            if (gameSettingsItem != null)
+            {
+                var gameSettingsWindow = Editor.Instance.Windows.FindEditor(gameSettingsItem) as JsonAssetWindow;
+                if (gameSettingsWindow?.Instance is GameSettings)
+                {
+                    if (TrySet(gameSettingsWindow.Instance as GameSettings, ResultUrl, _options.Type))
+                        gameSettingsWindow.MarkAsEdited();
+                }
+                else
+                {
+                    var gameSettingsAsset = FlaxEngine.Content.LoadAsync<JsonAsset>(gameSettingsItem.ID);
+                    if (gameSettingsAsset && !gameSettingsAsset.WaitForLoaded())
+                    {
+                        if (gameSettingsAsset.CreateInstance() is GameSettings settings)
+                        {
+                            if (TrySet(settings, ResultUrl, _options.Type))
+                            {
+                                Editor.SaveJsonAsset(GameSettings.GameSettingsAssetPath, settings);
+                            }
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        private static bool TrySet(GameSettings instance, string resultUrl, SettingsTypes type)
+        {
+            var asset = FlaxEngine.Content.LoadAsync<JsonAsset>(resultUrl);
+            if (instance != null && asset != null)
+            {
+                switch (type)
+                {
+                case SettingsTypes.AudioSettings:
+                    if (instance.Audio != null)
+                        return false;
+                    instance.Audio = asset;
+                    break;
+                case SettingsTypes.TimeSettings:
+                    if (instance.Time != null)
+                        return false;
+                    instance.Time = asset;
+                    break;
+                case SettingsTypes.LayersAndTagsSettings:
+                    if (instance.LayersAndTags != null)
+                        return false;
+                    instance.LayersAndTags = asset;
+                    break;
+                case SettingsTypes.PhysicsSettings:
+                    if (instance.Physics != null)
+                        return false;
+                    instance.Physics = asset;
+                    break;
+                case SettingsTypes.GraphicsSettings:
+                    if (instance.Graphics != null)
+                        return false;
+                    instance.Graphics = asset;
+                    break;
+                case SettingsTypes.NavigationSettings:
+                    if (instance.Navigation != null)
+                        return false;
+                    instance.Navigation = asset;
+                    break;
+                case SettingsTypes.LocalizationSettings:
+                    if (instance.Localization != null)
+                        return false;
+                    instance.Localization = asset;
+                    break;
+                case SettingsTypes.BuildSettings:
+                    if (instance.GameCooking != null)
+                        return false;
+                    instance.GameCooking = asset;
+                    break;
+                case SettingsTypes.InputSettings:
+                    if (instance.Input != null)
+                        return false;
+                    instance.Input = asset;
+                    break;
+                case SettingsTypes.StreamingSettings:
+                    if (instance.Streaming != null)
+                        return false;
+                    instance.Streaming = asset;
+                    break;
+                case SettingsTypes.WindowsPlatformSettings:
+                    if (instance.WindowsPlatform != null)
+                        return false;
+                    instance.WindowsPlatform = asset;
+                    break;
+                case SettingsTypes.UWPPlatformSettings:
+                    if (instance.UWPPlatform != null)
+                        return false;
+                    instance.UWPPlatform = asset;
+                    break;
+                case SettingsTypes.LinuxPlatformSettings:
+                    if (instance.LinuxPlatform != null)
+                        return false;
+                    instance.LinuxPlatform = asset;
+                    break;
+                case SettingsTypes.PS4PlatformSettings:
+                    if (instance.PS4Platform != null)
+                        return false;
+                    instance.PS4Platform = asset;
+                    break;
+                case SettingsTypes.XboxScarlettPlatformSettings:
+                    if (instance.XboxScarlettPlatform != null)
+                        return false;
+                    instance.XboxScarlettPlatform = asset;
+                    break;
+                case SettingsTypes.AndroidPlatformSettings:
+                    if (instance.AndroidPlatform != null)
+                        return false;
+                    instance.AndroidPlatform = asset;
+                    break;
+                case SettingsTypes.SwitchPlatformSettings:
+                    if (instance.SwitchPlatform != null)
+                        return false;
+                    instance.SwitchPlatform = asset;
+                    break;
+                }
+                return true;
+            }
+            return false;
         }
     }
 }

Source/Editor/Content/Create/VisualScriptCreateEntry.cs

@@ -25,7 +25,7 @@ namespace FlaxEditor.Content.Create
 
             private static bool IsValid(Type type)
             {
-                return type.IsPublic && !type.IsSealed && !type.IsGenericType;
+                return (type.IsPublic || type.IsNestedPublic) && !type.IsSealed && !type.IsGenericType;
             }
         }
 

Source/Editor/Content/GUI/ContentView.cs

@@ -27,6 +27,22 @@ namespace FlaxEditor.Content.GUI
         List,
     }
 
+    /// <summary>
+    /// The method sort for items.
+    /// </summary>
+    public enum SortType
+    {
+        /// <summary> 
+        /// The classic alphabetic sort method (A-Z).
+        /// </summary>
+        AlphabeticOrder,
+        
+        /// <summary>                    
+        /// The reverse alphabetic sort method (Z-A).
+        /// </summary>                   
+        AlphabeticReverse
+    }
+
     /// <summary>
     /// Main control for <see cref="ContentWindow"/> used to present collection of <see cref="ContentItem"/>.
     /// </summary>
@@ -218,8 +234,9 @@ namespace FlaxEditor.Content.GUI
         /// Shows the items collection in the view.
         /// </summary>
         /// <param name="items">The items to show.</param>
+        /// <param name="sortType">The sort method for items.</param>
         /// <param name="additive">If set to <c>true</c> items will be added to the current selection. Otherwise selection will be cleared before.</param>
-        public void ShowItems(List<ContentItem> items, bool additive = false)
+        public void ShowItems(List<ContentItem> items, SortType sortType, bool additive = false)
         {
             if (items == null)
                 throw new ArgumentNullException();
@@ -249,8 +266,23 @@ namespace FlaxEditor.Content.GUI
                 items[i].AddReference(this);
             }
 
-            // Sort items
-            _children.Sort();
+            // Sort items depending on sortMethod parameter
+            _children.Sort(((control, control1) =>
+                               {
+                                   if (sortType == SortType.AlphabeticReverse)
+                                   {
+                                       if (control.CompareTo(control1) > 0)
+                                       {
+                                           return -1; 
+                                       }
+                                       if (control.CompareTo(control1) == 0)
+                                       {
+                                           return 0;    
+                                       }
+                                       return 1;
+                                   }
+                                   return control.CompareTo(control1);
+                               }));
             
             // Unload and perform UI layout
             IsLayoutLocked = wasLayoutLocked;

Source/Editor/Content/Import/ImportFileEntry.cs

@@ -113,12 +113,10 @@ namespace FlaxEditor.Content.Import
             extension = extension.ToLower();
 
             // Check if use overriden type
-            ImportFileEntryHandler createDelegate;
-            if (FileTypes.TryGetValue(extension, out createDelegate))
+            if (FileTypes.TryGetValue(extension, out ImportFileEntryHandler createDelegate))
                 return createDelegate(ref request);
 
-            // Use default type
-            return request.IsBinaryAsset ? new AssetImportEntry(ref request) : new ImportFileEntry(ref request);
+            return request.IsInBuilt ? new AssetImportEntry(ref request) : new ImportFileEntry(ref request);
         }
 
         internal static void RegisterDefaultTypes()

Source/Editor/Content/Import/ImportFilesDialog.cs

@@ -32,7 +32,7 @@ namespace FlaxEditor.Content.Import
                 var result = 0;
                 for (int i = 0; i < _rootNode.ChildrenCount; i++)
                 {
-                    if (_rootNode.Children[i].Tag is ImportFileEntry fileEntry)
+                    if (_rootNode.Children[i].Tag is ImportFileEntry)
                         result++;
                 }
                 return result;
@@ -215,8 +215,7 @@ namespace FlaxEditor.Content.Import
             var entries = new List<ImportFileEntry>(_rootNode.ChildrenCount);
             for (int i = 0; i < _rootNode.ChildrenCount; i++)
             {
-                var fileEntry = _rootNode.Children[i].Tag as ImportFileEntry;
-                if (fileEntry != null)
+                if (_rootNode.Children[i].Tag is ImportFileEntry fileEntry)
                     entries.Add(fileEntry);
             }
             Editor.Instance.ContentImporting.LetThemBeImportedxD(entries);

Source/Editor/Content/Import/ModelImportEntry.cs

@@ -117,8 +117,8 @@ namespace FlaxEditor.Content.Import
         /// <summary>
         /// True if calculate model tangents, otherwise will import them.
         /// </summary>
-        [EditorOrder(40), DefaultValue(true), EditorDisplay("Geometry"), Tooltip("Enable model tangent vectors recalculating")]
-        public bool CalculateTangents { get; set; } = true;
+        [EditorOrder(40), DefaultValue(false), EditorDisplay("Geometry"), Tooltip("Enable model tangent vectors recalculating")]
+        public bool CalculateTangents { get; set; } = false;
 
         /// <summary>
         /// Calculated normals smoothing angle.

Source/Editor/Content/Import/Request.cs

@@ -21,9 +21,9 @@ namespace FlaxEditor.Content.Import
         public string OutputPath;
 
         /// <summary>
-        /// Flag set to true for binary assets handled by the engine internally.
+        /// Flag set to true for the assets handled by the engine internally.
         /// </summary>
-        public bool IsBinaryAsset;
+        public bool IsInBuilt;
 
         /// <summary>
         /// Flag used to skip showing import settings dialog to used. Can be used for importing assets from code by plugins.

Source/Editor/Content/Import/TextureImportEntry.cs

@@ -283,6 +283,13 @@ namespace FlaxEditor.Content.Import
         [EditorOrder(250), VisibleIf("PreserveAlphaCoverage"), DefaultValue(0.5f), Tooltip("The reference value for the alpha coverage preserving.")]
         public float PreserveAlphaCoverageReference { get; set; } = 0.5f;
 
+        /// <summary>
+        /// Texture group for streaming (negative if unused). See Streaming Settings.
+        /// </summary>
+        [CustomEditor(typeof(CustomEditors.Dedicated.TextureGroupEditor))]
+        [EditorOrder(300), Tooltip("Texture group for streaming (negative if unused). See Streaming Settings.")]
+        public int TextureGroup = -1;
+
         /// <summary>
         /// The sprites. Used to keep created sprites on sprite atlas reimport.
         /// </summary>
@@ -305,6 +312,7 @@ namespace FlaxEditor.Content.Import
             public float PreserveAlphaCoverageReference;
             public float Scale;
             public int MaxSize;
+            public int TextureGroup;
             public Int2 Size;
             public Rectangle[] SpriteAreas;
             public string[] SpriteNames;
@@ -327,7 +335,8 @@ namespace FlaxEditor.Content.Import
                 PreserveAlphaCoverageReference = PreserveAlphaCoverageReference,
                 Scale = Scale,
                 Size = Size,
-                MaxSize = (int)MaxSize
+                MaxSize = (int)MaxSize,
+                TextureGroup = TextureGroup,
             };
             if (Sprites != null && Sprites.Count > 0)
             {
@@ -362,6 +371,7 @@ namespace FlaxEditor.Content.Import
             PreserveAlphaCoverageReference = options.PreserveAlphaCoverageReference;
             Scale = options.Scale;
             MaxSize = ConvertMaxSize(options.MaxSize);
+            TextureGroup = options.TextureGroup;
             Size = options.Size;
             if (options.SpriteAreas != null)
             {
@@ -483,7 +493,9 @@ namespace FlaxEditor.Content.Import
         {
             if (settings is TextureImportSettings o)
             {
+                var sprites = o.Sprites ?? _settings.Sprites; // Preserve sprites if not specified to override
                 _settings = o;
+                _settings.Sprites = sprites;
                 return true;
             }
             return false;

Source/Editor/Content/Items/AssetItem.cs

@@ -108,6 +108,26 @@ namespace FlaxEditor.Content
             return false;
         }
 
+        /// <summary>
+        /// Called when user dags this item into editor viewport or scene tree node.
+        /// </summary>
+        /// <param name="context">The editor context (eg. editor viewport or scene tree node).</param>
+        /// <returns>True if item can be dropped in, otherwise false.</returns>
+        public virtual bool OnEditorDrag(object context)
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// Called when user drops the item into editor viewport or scene tree node.
+        /// </summary>
+        /// <param name="context">The editor context (eg. editor viewport or scene tree node).</param>
+        /// <returns>The spawned object.</returns>
+        public virtual Actor OnEditorDrop(object context)
+        {
+            throw new NotSupportedException($"Asset {GetType()} doesn't support dropping into viewport.");
+        }
+
         /// <inheritdoc />
         protected override bool DrawShadow => true;
 

Source/Editor/Content/Items/BinaryAssetItem.cs

@@ -103,14 +103,26 @@ namespace FlaxEditor.Content
     /// Implementation of <see cref="BinaryAssetItem"/> for <see cref="Model"/> assets.
     /// </summary>
     /// <seealso cref="FlaxEditor.Content.BinaryAssetItem" />
-    public class ModelAssetItem : BinaryAssetItem
+    public class ModelItem : BinaryAssetItem
     {
         /// <inheritdoc />
-        public ModelAssetItem(string path, ref Guid id, string typeName, Type type)
+        public ModelItem(string path, ref Guid id, string typeName, Type type)
         : base(path, ref id, typeName, type, ContentItemSearchFilter.Model)
         {
         }
 
+        /// <inheritdoc />
+        public override bool OnEditorDrag(object context)
+        {
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return new StaticModel { Model = FlaxEngine.Content.LoadAsync<Model>(ID) };
+        }
+
         /// <inheritdoc />
         protected override void OnBuildTooltipText(StringBuilder sb)
         {
@@ -142,14 +154,26 @@ namespace FlaxEditor.Content
     /// Implementation of <see cref="BinaryAssetItem"/> for <see cref="SkinnedModel"/> assets.
     /// </summary>
     /// <seealso cref="FlaxEditor.Content.BinaryAssetItem" />
-    public class SkinnedModelAssetItem : BinaryAssetItem
+    public class SkinnedModeItem : BinaryAssetItem
     {
         /// <inheritdoc />
-        public SkinnedModelAssetItem(string path, ref Guid id, string typeName, Type type)
+        public SkinnedModeItem(string path, ref Guid id, string typeName, Type type)
         : base(path, ref id, typeName, type, ContentItemSearchFilter.Model)
         {
         }
 
+        /// <inheritdoc />
+        public override bool OnEditorDrag(object context)
+        {
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return new AnimatedModel { SkinnedModel = FlaxEngine.Content.LoadAsync<SkinnedModel>(ID) };
+        }
+
         /// <inheritdoc />
         protected override void OnBuildTooltipText(StringBuilder sb)
         {

Source/Editor/Content/Items/CSharpScriptItem.cs

@@ -20,6 +20,6 @@ namespace FlaxEditor.Content
         }
         
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.CSharpScript64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.CSharpScript128;
     }
 }

Source/Editor/Content/Items/ContentFolder.cs

@@ -121,7 +121,7 @@ namespace FlaxEditor.Content
         public override bool Exists => Directory.Exists(Path);
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Folder64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Folder128;
 
         /// <inheritdoc />
         internal override void UpdatePath(string value)

Source/Editor/Content/Items/ContentItem.cs

@@ -455,7 +455,7 @@ namespace FlaxEditor.Content
                 const float thumbnailInShadowSize = 50.0f;
                 var shadowRect = rectangle.MakeExpanded((DefaultThumbnailSize - thumbnailInShadowSize) * rectangle.Width / DefaultThumbnailSize * 1.3f);
                 if (!_shadowIcon.IsValid)
-                    _shadowIcon = Editor.Instance.Icons.AssetShadow;
+                    _shadowIcon = Editor.Instance.Icons.AssetShadow128;
                 Render2D.DrawSprite(_shadowIcon, shadowRect);
             }
 
@@ -599,7 +599,7 @@ namespace FlaxEditor.Content
         public override bool OnShowTooltip(out string text, out Vector2 location, out Rectangle area)
         {
             UpdateTooltipText();
-            var result = base.OnShowTooltip(out text, out location, out area);
+            var result = base.OnShowTooltip(out text, out _, out area);
             location = Size * new Vector2(0.9f, 0.5f);
             return result;
         }

Source/Editor/Content/Items/CppScriptItem.cs

@@ -20,6 +20,6 @@ namespace FlaxEditor.Content
         }
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.CppScript64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.CPPScript128;
     }
 }

Source/Editor/Content/Items/FileItem.cs

@@ -26,6 +26,6 @@ namespace FlaxEditor.Content
         public override ContentItemSearchFilter SearchFilter => ContentItemSearchFilter.Other;
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document128;
     }
 }

Source/Editor/Content/Items/JsonAssetItem.cs

@@ -11,6 +11,8 @@ namespace FlaxEditor.Content
     /// <seealso cref="FlaxEditor.Content.AssetItem" />
     public class JsonAssetItem : AssetItem
     {
+        private readonly SpriteHandle _thumbnail;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="JsonAssetItem"/> class.
         /// </summary>
@@ -20,13 +22,27 @@ namespace FlaxEditor.Content
         public JsonAssetItem(string path, Guid id, string typeName)
         : base(path, typeName, ref id)
         {
+            _thumbnail = Editor.Instance.Icons.Json128;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonAssetItem"/> class.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <param name="id">The identifier.</param>
+        /// <param name="typeName">Name of the resource type.</param>
+        /// <param name="thumbnail">Asset icon.</param>
+        public JsonAssetItem(string path, Guid id, string typeName, SpriteHandle thumbnail)
+        : base(path, typeName, ref id)
+        {
+            _thumbnail = thumbnail;
         }
 
         /// <inheritdoc />
         public override ContentItemSearchFilter SearchFilter => ContentItemSearchFilter.Json;
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document64;
+        public override SpriteHandle DefaultThumbnail => _thumbnail;
 
         /// <inheritdoc />
         protected override bool DrawShadow => false;

Source/Editor/Content/Items/NewItem.cs

@@ -40,7 +40,7 @@ namespace FlaxEditor.Content
         public override ContentItemSearchFilter SearchFilter => ContentItemSearchFilter.Other;
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document128;
 
         /// <inheritdoc />
         protected override bool DrawShadow => true;

Source/Editor/Content/Items/PrefabItem.cs

@@ -21,6 +21,18 @@ namespace FlaxEditor.Content
         {
         }
 
+        /// <inheritdoc />
+        public override bool OnEditorDrag(object context)
+        {
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return PrefabManager.SpawnPrefab(FlaxEngine.Content.LoadAsync<Prefab>(ID), null);
+        }
+
         /// <inheritdoc />
         public override ContentItemType ItemType => ContentItemType.Asset;
 

Source/Editor/Content/Items/SceneItem.cs

@@ -28,7 +28,7 @@ namespace FlaxEditor.Content
         public override ContentItemSearchFilter SearchFilter => ContentItemSearchFilter.Scene;
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Scene64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Scene128;
 
         /// <inheritdoc />
         public override bool IsOfType(Type type)

Source/Editor/Content/Items/ShaderSourceItem.cs

@@ -27,6 +27,6 @@ namespace FlaxEditor.Content
         public override ContentItemSearchFilter SearchFilter => ContentItemSearchFilter.Shader;
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document64;
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.Document128;
     }
 }

Source/Editor/Content/Items/VisualScriptItem.cs

@@ -50,6 +50,9 @@ namespace FlaxEditor.Content
         /// <inheritdoc />
         public bool IsMethod => false;
 
+        /// <inheritdoc />
+        public bool IsEvent => false;
+
         /// <inheritdoc />
         public bool HasGet => true;
 
@@ -72,6 +75,9 @@ namespace FlaxEditor.Content
             }
         }
 
+        /// <inheritdoc />
+        public int MetadataToken => 0;
+
         /// <inheritdoc />
         public bool HasAttribute(Type attributeType, bool inherit)
         {
@@ -174,6 +180,9 @@ namespace FlaxEditor.Content
         /// <inheritdoc />
         public bool IsMethod => true;
 
+        /// <inheritdoc />
+        public bool IsEvent => false;
+
         /// <inheritdoc />
         public bool HasGet => false;
 
@@ -189,6 +198,8 @@ namespace FlaxEditor.Content
         /// <inheritdoc />
         public ScriptType ValueType => _returnType;
 
+        public int MetadataToken => 0;
+
         /// <inheritdoc />
         public bool HasAttribute(Type attributeType, bool inherit)
         {
@@ -528,7 +539,19 @@ namespace FlaxEditor.Content
         }
 
         /// <inheritdoc />
-        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.CodeScript64;
+        public override bool OnEditorDrag(object context)
+        {
+            return new ScriptType(typeof(Actor)).IsAssignableFrom(ScriptType) && ScriptType.CanCreateInstance;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return (Actor)ScriptType.CreateInstance();
+        }
+
+        /// <inheritdoc />
+        public override SpriteHandle DefaultThumbnail => Editor.Instance.Icons.VisualScript128;
 
         /// <inheritdoc />
         protected override bool DrawShadow => false;

Source/Editor/Content/PreviewsCache.cpp

@@ -76,7 +76,7 @@ void PreviewsCache::FlushTask::OnEnd()
     ThreadPoolTask::OnEnd();
 }
 
-REGISTER_BINARY_ASSET(PreviewsCache, "FlaxEditor.PreviewsCache", ::New<TextureAssetUpgrader>(), false);
+REGISTER_BINARY_ASSET_WITH_UPGRADER(PreviewsCache, "FlaxEditor.PreviewsCache", TextureAssetUpgrader, false);
 
 PreviewsCache::PreviewsCache(const SpawnParams& params, const AssetInfo* info)
     : SpriteAtlas(params, info)
@@ -241,16 +241,13 @@ CreateAssetResult PreviewsCache::create(CreateAssetContext& context)
     IMPORT_SETUP(PreviewsCache, 4);
 
     // Create texture header (custom data)
-    TextureHeader header;
-    header.Width = ASSETS_ICONS_ATLAS_SIZE;
-    header.Height = ASSETS_ICONS_ATLAS_SIZE;
-    header.Format = ASSETS_ICONS_ATLAS_FORMAT;
-    header.IsSRGB = false;
-    header.IsCubeMap = false;
-    header.MipLevels = 1;
-    header.NeverStream = true;
-    header.Type = TextureFormatType::Unknown;
-    context.Data.CustomData.Copy(&header);
+    TextureHeader textureHeader;
+    textureHeader.Width = ASSETS_ICONS_ATLAS_SIZE;
+    textureHeader.Height = ASSETS_ICONS_ATLAS_SIZE;
+    textureHeader.Format = ASSETS_ICONS_ATLAS_FORMAT;
+    textureHeader.MipLevels = 1;
+    textureHeader.NeverStream = true;
+    context.Data.CustomData.Copy(&textureHeader);
 
     // Create blank image (chunk 0)
     uint64 imageSize = CalculateTextureMemoryUsage(ASSETS_ICONS_ATLAS_FORMAT, ASSETS_ICONS_ATLAS_SIZE, ASSETS_ICONS_ATLAS_SIZE, 1);

Source/Editor/Content/Proxy/AudioClipProxy.cs

@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Text;
 using FlaxEditor.Content.Thumbnails;
 using FlaxEditor.Viewport.Previews;
 using FlaxEditor.Windows;
@@ -11,11 +12,51 @@ using FlaxEngine.GUI;
 
 namespace FlaxEditor.Content
 {
+    /// <summary>
+    /// Implementation of <see cref="BinaryAssetItem"/> for <see cref="AudioClip"/> assets.
+    /// </summary>
+    /// <seealso cref="FlaxEditor.Content.BinaryAssetItem" />
+    class AudioClipItem : BinaryAssetItem
+    {
+        /// <inheritdoc />
+        public AudioClipItem(string path, ref Guid id, string typeName, Type type)
+        : base(path, ref id, typeName, type, ContentItemSearchFilter.Audio)
+        {
+        }
+
+        /// <inheritdoc />
+        public override bool OnEditorDrag(object context)
+        {
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return new AudioSource { Clip = FlaxEngine.Content.LoadAsync<AudioClip>(ID) };
+        }
+
+        /// <inheritdoc />
+        protected override void OnBuildTooltipText(StringBuilder sb)
+        {
+            base.OnBuildTooltipText(sb);
+
+            var asset = FlaxEngine.Content.Load<AudioClip>(ID, 100);
+            if (asset)
+            {
+                var info = asset.Info;
+                sb.Append("Duration: ").Append(asset.Length).AppendLine();
+                sb.Append("Channels: ").Append(info.NumChannels).AppendLine();
+                sb.Append("Bit Depth: ").Append(info.BitDepth).AppendLine();
+            }
+        }
+    }
+
     /// <summary>
     /// A <see cref="AudioClip"/> asset proxy object.
     /// </summary>
     /// <seealso cref="FlaxEditor.Content.BinaryAssetProxy" />
-    public class AudioClipProxy : BinaryAssetProxy
+    class AudioClipProxy : BinaryAssetProxy
     {
         private List<AudioClipPreview> _previews;
 
@@ -34,6 +75,12 @@ namespace FlaxEditor.Content
             return new AudioClipWindow(editor, (AssetItem)item);
         }
 
+        /// <inheritdoc />
+        public override AssetItem ConstructItem(string path, string typeName, ref Guid id)
+        {
+            return new AudioClipItem(path, ref id, typeName, AssetType);
+        }
+
         /// <inheritdoc />
         public override Color AccentColor => Color.FromRGB(0xB3452B);
 

Source/Editor/Content/Proxy/BinaryAssetProxy.cs

@@ -47,9 +47,9 @@ namespace FlaxEditor.Content
             if (typeof(TextureBase).IsAssignableFrom(type))
                 return new TextureAssetItem(path, ref id, typeName, type);
             if (typeof(Model).IsAssignableFrom(type))
-                return new ModelAssetItem(path, ref id, typeName, type);
+                return new ModelItem(path, ref id, typeName, type);
             if (typeof(SkinnedModel).IsAssignableFrom(type))
-                return new SkinnedModelAssetItem(path, ref id, typeName, type);
+                return new SkinnedModeItem(path, ref id, typeName, type);
 
             ContentItemSearchFilter searchFilter;
             if (typeof(MaterialBase).IsAssignableFrom(type))
@@ -58,11 +58,9 @@ namespace FlaxEditor.Content
                 searchFilter = ContentItemSearchFilter.Prefab;
             else if (typeof(SceneAsset).IsAssignableFrom(type))
                 searchFilter = ContentItemSearchFilter.Scene;
-            else if (typeof(AudioClip).IsAssignableFrom(type))
-                searchFilter = ContentItemSearchFilter.Audio;
             else if (typeof(Animation).IsAssignableFrom(type))
                 searchFilter = ContentItemSearchFilter.Animation;
-            else if (typeof(ParticleEmitter).IsAssignableFrom(type) || typeof(ParticleSystem).IsAssignableFrom(type))
+            else if (typeof(ParticleEmitter).IsAssignableFrom(type))
                 searchFilter = ContentItemSearchFilter.Particles;
             else
                 searchFilter = ContentItemSearchFilter.Other;

Source/Editor/Content/Proxy/CollisionDataProxy.cs

@@ -8,11 +8,36 @@ using FlaxEngine;
 
 namespace FlaxEditor.Content
 {
+    /// <summary>
+    /// Implementation of <see cref="BinaryAssetItem"/> for <see cref="CollisionData"/> assets.
+    /// </summary>
+    /// <seealso cref="FlaxEditor.Content.BinaryAssetItem" />
+    class CollisionDataItem : BinaryAssetItem
+    {
+        /// <inheritdoc />
+        public CollisionDataItem(string path, ref Guid id, string typeName, Type type)
+        : base(path, ref id, typeName, type, ContentItemSearchFilter.Other)
+        {
+        }
+
+        /// <inheritdoc />
+        public override bool OnEditorDrag(object context)
+        {
+            return true;
+        }
+
+        /// <inheritdoc />
+        public override Actor OnEditorDrop(object context)
+        {
+            return new MeshCollider { CollisionData = FlaxEngine.Content.LoadAsync<CollisionData>(ID) };
+        }
+    }
+
     /// <summary>
     /// A <see cref="CollisionData"/> asset proxy object.
     /// </summary>
     /// <seealso cref="FlaxEditor.Content.BinaryAssetProxy" />
-    public class CollisionDataProxy : BinaryAssetProxy
+    class CollisionDataProxy : BinaryAssetProxy
     {
         /// <inheritdoc />
         public override string Name => "Collision Data";
@@ -23,6 +48,12 @@ namespace FlaxEditor.Content
             return new CollisionDataWindow(editor, item as AssetItem);
         }
 
+        /// <inheritdoc />
+        public override AssetItem ConstructItem(string path, string typeName, ref Guid id)
+        {
+            return new CollisionDataItem(path, ref id, typeName, AssetType);
+        }
+
         /// <inheritdoc />
         public override Color AccentColor => Color.FromRGB(0x2c3e50);
 
@@ -46,24 +77,47 @@ namespace FlaxEditor.Content
         /// Create collision data from model.
         /// </summary>
         /// <param name="model">The associated model.</param>
-        public void CreateCollisionDataFromModel(Model model)
+        /// <param name="created">The action to call once the collision data gets created (or reused from existing).</param>
+        public void CreateCollisionDataFromModel(Model model, Action<CollisionData> created = null)
         {
-            Action<ContentItem> created = contentItem =>
+            // Check if there already is collision data for that model to reuse
+            var modelItem = (AssetItem)Editor.Instance.ContentDatabase.Find(model.ID);
+            if (modelItem?.ParentFolder != null)
             {
-                var ai = (AssetItem)contentItem;
-                var cd = FlaxEngine.Content.LoadAsync<CollisionData>(ai.ID);
-                if (cd == null || cd.WaitForLoaded())
+                foreach (var child in modelItem.ParentFolder.Children)
+                {
+                    if (child is BinaryAssetItem b && b.IsOfType<CollisionData>())
+                    {
+                        var collisionData = FlaxEngine.Content.Load<CollisionData>(b.ID);
+                        if (collisionData && collisionData.Options.Model == model.ID)
+                        {
+                            Editor.Instance.Windows.ContentWin.Select(b);
+                            if (created != null)
+                                FlaxEngine.Scripting.InvokeOnUpdate(() => created(collisionData));
+                            return;
+                        }
+                    }
+                }
+            }
+
+            // Create new item so user can name it and then generate collision for it in async
+            Action<ContentItem> create = contentItem =>
+            {
+                var assetItem = (AssetItem)contentItem;
+                var collisionData = FlaxEngine.Content.LoadAsync<CollisionData>(assetItem.ID);
+                if (collisionData == null || collisionData.WaitForLoaded())
                 {
                     Editor.LogError("Failed to load created collision data.");
                     return;
                 }
-
                 Task.Run(() =>
                 {
-                    Editor.CookMeshCollision(ai.Path, CollisionDataType.TriangleMesh, model);
+                    Editor.CookMeshCollision(assetItem.Path, CollisionDataType.TriangleMesh, model);
+                    if (created != null)
+                        FlaxEngine.Scripting.InvokeOnUpdate(() => created(collisionData));
                 });
             };
-            Editor.Instance.Windows.ContentWin.NewItem(this, null, created);
+            Editor.Instance.Windows.ContentWin.NewItem(this, null, create);
         }
     }
 }