Separated Assets to Resources (Engine assets) and Assets (Project specific)

+ AssetHierarchy: Exposed RootNode
+ ContentBrowserWindow: Fixed Empty Folder not being Leaf-Node
+ TreeNode: Added IsParentOf, IsChildOf and IsInSubtree.
    + Fixed InternalDeleteTreeAndChildren for null trees

GlitchyEditor/resources/Shaders/ACES.hlsl

@@ -0,0 +1,52 @@
+//=================================================================================================
+//
+//  Baking Lab
+//  by MJP and David Neubelt
+//  http://mynameismjp.wordpress.com/
+//
+//  All code licensed under the MIT license
+//
+//=================================================================================================
+
+// The code in this file was originally written by Stephen Hill (@self_shadow), who deserves all
+// credit for coming up with this fit and implementing it. Buy him a beer next time you see him. :)
+
+// Source: https://github.com/TheRealMJP/BakingLab/blob/master/BakingLab/ACES.hlsl
+
+// sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
+static const float3x3 ACESInputMat =
+{
+    {0.59719, 0.35458, 0.04823},
+    {0.07600, 0.90834, 0.01566},
+    {0.02840, 0.13383, 0.83777}
+};
+
+// ODT_SAT => XYZ => D60_2_D65 => sRGB
+static const float3x3 ACESOutputMat =
+{
+    { 1.60475, -0.53108, -0.07367},
+    {-0.10208,  1.10813, -0.00605},
+    {-0.00327, -0.07276,  1.07602}
+};
+
+float3 RRTAndODTFit(float3 v)
+{
+    float3 a = v * (v + 0.0245786f) - 0.000090537f;
+    float3 b = v * (0.983729f * v + 0.4329510f) + 0.238081f;
+    return a / b;
+}
+
+float3 ACESFitted(float3 color)
+{
+    color = mul(ACESInputMat, color);
+
+    // Apply RRT and ODT
+    color = RRTAndODTFit(color);
+
+    color = mul(ACESOutputMat, color);
+
+    // Clamp to [0, 1]
+    color = saturate(color);
+
+    return color;
+}

GlitchyEditor/resources/Shaders/ACES.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}

GlitchyEditor/resources/Shaders/ClearUInt.hlsl

@@ -0,0 +1,16 @@
+cbuffer Constants : register(b0)
+{
+    uint ClearValue;
+}
+
+float4 VS(float2 input : POSITION) : SV_Position
+{
+    return float4(input, 0.0f, 1.0f);
+}
+
+uint PS(float4 input : SV_Position) : SV_Target0
+{
+    return ClearValue;
+}
+
+#pragma Effect[VS = VS; PS = PS]

GlitchyEditor/resources/Shaders/ClearUInt.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}

GlitchyEditor/resources/Shaders/GammaCorrect.hlsl

@@ -0,0 +1,33 @@
+Texture2D Texture : register(t0);
+SamplerState TextureSampler : register(s0);
+
+struct VS_IN
+{
+	float2 Position : POSITION;
+	float2 TexCoord : TEXCOORD0;
+};
+
+struct PS_IN
+{
+	float4 Position : SV_POSITION;
+	float2 TexCoord : TEXCOORD;
+};
+
+PS_IN VS(VS_IN input)
+{
+	PS_IN output;
+
+	output.Position = float4(input.Position, 0, 1);
+	output.TexCoord = input.TexCoord;
+
+	return output;
+}
+
+float4 PS(PS_IN input) : SV_TARGET
+{
+	float4 color = Texture.Sample(TextureSampler, input.TexCoord);
+
+	return float4(pow(color.rgb, 1.0f / 2.2f), color.a);
+}
+
+#pragma Effect[VS = VS; PS = PS]

GlitchyEditor/resources/Shaders/GammaCorrect.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}

GlitchyEditor/resources/Shaders/GlitchyEngine.hlsl

@@ -0,0 +1,59 @@
+#pragma EngineBuffer[ Name = "SceneConstants"; Binding = "Scene" ]
+cbuffer SceneConstants : register(b0)
+{
+    float4x4 ViewProjection;
+}
+
+#pragma EngineBuffer[ Name = "ObjectConstants"; Binding = "Object" ]
+cbuffer ObjectConstants : register(b1)
+{
+    float4x4 Transform;
+    /**
+     * \brief Inverted and transposed transform matrix.
+     * \remarks This matrix is used in order to correctly transform normal vectors.
+     */
+    float4x3 Transform_InvT;
+#ifdef OutputEntityId
+    uint EntityId;
+#endif
+}
+
+/**
+ * \brief Pixel Shader output for lit surfaces.
+ */
+struct PS_OUT_Lit
+{
+    /** RGB: Albedo A: Transparency */
+    float4 Albedo : SV_TARGET0;
+    /** RG: TextureNormal.XY | BA: GeoNrm.XY */
+    float4 Normal : SV_TARGET1;
+    /** R: GeoNrm.Z | GBA: GeoTan.XYZ */
+    float4 Tangent : SV_TARGET2;
+    /** RGB: world position XYZ | A: 1.0 */
+    float4 Position : SV_TARGET3;
+    /** RGB: emissive light and color | A: unused */
+    float4 Emissive : SV_TARGET4;
+    /** R: Metallicity | G: Roughness | B: Ambient | A: Unused */
+    float4 Material : SV_TARGET5;
+#ifdef OutputEntityId
+    /** Needed for editor picking. Simply pass through the EntityId. */
+    uint EntityId : SV_TARGET6;
+#endif
+};
+
+/**
+ * \brief Pixel Shader output for unlit surfaces.
+ */
+struct PS_OUT_Unlit
+{
+    /** RGB: Color A: Transparency */
+    float4 Color : SV_TARGET0;
+    /** RGB: emissive light and color | A: unused */
+    float4 Emissive : SV_TARGET1;
+    /** RGB: world position XYZ | A: 1.0 */
+    float4 Position : SV_TARGET2;
+
+#ifdef OutputEntityId
+    uint EntityId : SV_TARGET5;
+#endif
+};

GlitchyEditor/resources/Shaders/GlitchyEngine.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}/* No reflection data for GlitchyEditor.Assets.EffectAssetLoaderConfig. Add [BonTarget] or force it */
+}

GlitchyEditor/resources/Shaders/LightingFunctions.hlsl

@@ -0,0 +1,28 @@
+#define PI 3.14159265358979323846f
+
+/**
+ * Calculates the diffuse lighting of a lambertian surface
+ * @param diffuseColor (rho/ pi) * C_diffuse
+ * @param illuminanceColor The product of the "brightness" and the light color.
+ * @param n_dot_l The dot product of the surface normal and the light direction.
+ */
+float3 CalculateDiffuseReflection(float3 diffuseColor, float3 illuminanceColor, float3 n_dot_l)
+{
+    float3 directColor = illuminanceColor * saturate(n_dot_l);
+
+    return (directColor * diffuseColor);
+}
+
+/**
+ * Calculates the blinn-phong-specular reflection
+ * @param n The normalized surface normal
+ * @param h The normalized half way vector (nrm(l + v))
+ * @param alpha The reflections alpha-value
+ * @param illuminanceColor The product of the "brightness" and the light color.
+ * @param n_dot_l The dot product of the surface normal and the light direction.
+ */
+float3 CalculateSpecularReflection(float3 n, float3 h, float alpha, float3 illuminanceColor, float n_dot_l)
+{
+    float highlight = pow(saturate(dot(n, h)), alpha) * float(n_dot_l > 0.0);
+    return (illuminanceColor * highlight); // Todo:  * SpecularColor
+}

GlitchyEditor/resources/Shaders/LightingFunctions.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}

GlitchyEditor/resources/Shaders/PBR.hlsl

@@ -0,0 +1,78 @@
+/*
+ * This File contains Function for PBR.
+ */
+
+#ifndef __PBR_HLSL__
+#define __PBR_HLSL__
+
+#include "ShaderHelpers.hlsl"
+
+// #define PBR_IBL
+
+ /**
+  * Normal Distribution Function. (Trowbridge-Reits GGX)
+  * Calculates the relative surface area of microfacets exactly aligned to the halfway vector.
+  * @param normal The surface normal.
+  * @param halfway The halfway vector between the surface normal and the view direction.
+  * @param roughness Roughness value.
+  * @returns The relative surface area of microfacets exactly aligned to the halfway vector.
+  */
+float NormalDistributionGGX(float3 normal, float3 halfway, float roughness)
+{
+	// Square roughness because it looks better
+	float a = roughness * roughness;
+	float aa = a * a;
+
+	float n_dot_h = max(dot(normal, halfway), 0.0f);
+
+	float denom = (n_dot_h * n_dot_h) * (aa - 1.0f) + 1.0f;
+	denom = PI * denom * denom;
+
+	return aa / denom;
+}
+
+/**
+ * Geometry Function calculating the overshadowing of microfacets based on roughness. (Schlick-Beckmann GGX).
+ * @param dot-product of normal vector and vector from surface to camera.
+ * @param k Roughness value.
+ */
+float GeometrySchlickGGX(float n_dot_v, float k)
+{
+	return n_dot_v / (n_dot_v * (1 - k) + k);
+}
+
+/**
+ * Geometry Function calculating the overshadowing of microfacets based on roughness. (Smith)
+ * @param normal The surface normal.
+ * @param viewDir Vector from surface to viewer.
+ * @param lightDir Vector from surface to light source.
+ * @param roughness Roughness value.
+ */
+float GeometrySmith(float3 normal, float3 viewDir, float3 lightDir, float roughness)
+{
+#ifdef PBR_IBL
+	// IBL
+	float k = roughness * roughness / 2;
+#else
+	// Direct lighting
+	float k = (roughness + 1.0f);
+	k = (k * k) / 8;
+#endif
+
+	const float n_dot_v = max(dot(normal, viewDir), 0.0f);
+	float n_dot_l = max(dot(normal, lightDir), 0.0f);
+
+	return GeometrySchlickGGX(n_dot_v, k) * GeometrySchlickGGX(n_dot_l, k);
+}
+
+/**
+ * Calculates the fresnel value.
+ * @param n_dot_v Dot product of the normal and view direction
+ * @param F0 base reflectivity.
+ */
+float3 FresnelSchlick(float n_dot_v, float3 F0)
+{
+	return F0 + (1.0 - F0) * pow(clamp(1.0 - n_dot_v, 0.0, 1.0), 5.0);
+}
+
+#endif // __PBR_HLSL__

GlitchyEditor/resources/Shaders/PBR.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}

GlitchyEditor/resources/Shaders/RenderTargetGroupViewer.hlsl

@@ -0,0 +1,111 @@
+Texture2DArray Texture : register(t0);
+SamplerState Sampler : register(s0);
+
+Texture2DArray<int4> IntTexture : register(t1);
+SamplerState IntSampler : register(s1);
+
+Texture2DArray<uint4> UIntTexture : register(t2);
+SamplerState UIntSampler : register(s2);
+
+#define SWIZZLE_NONE 0
+#define SWIZZLE_R 1
+#define SWIZZLE_G 2
+#define SWIZZLE_B 3
+#define SWIZZLE_A 4
+
+cbuffer Constants
+{
+    float ColorOffset = 0.5;
+    float AlphaOffset = 0.0;
+    float ColorScale = 0.5;
+    float AlphaScale = 1.0;
+
+    float MipLevel = 0.0;
+    float ArraySlice = 0.0;
+
+    // 0: Float | 1: Int | 2: Uint
+    int Mode = 0;
+
+    int4 Swizzle = int4(SWIZZLE_R, SWIZZLE_G, SWIZZLE_B, SWIZZLE_A);
+
+    float2 Texels;
+
+    float4x4 WorldViewProjection;
+}
+
+struct VS_Input
+{
+    float2 Position     : POSITION;
+    float2 Texcoord     : TEXCOORD0;
+};
+
+struct PS_Input
+{
+    float4 Position : SV_Position;
+    float2 Texcoord : TEXCOORD0;
+};
+
+PS_Input VS(VS_Input input)
+{
+    PS_Input output;
+
+    output.Position = mul(WorldViewProjection, float4(input.Position, 0.0f, 1.0f));
+    output.Texcoord = input.Texcoord;
+
+    return output;
+}
+
+void SwizzleColor(int swizzleMode, float4 colorToSwizzle, inout float output)
+{
+    switch (swizzleMode)
+    {
+	    case SWIZZLE_R:
+            output = colorToSwizzle.r;
+            break;
+	    case SWIZZLE_G:
+            output = colorToSwizzle.g;
+            break;
+	    case SWIZZLE_B:
+            output = colorToSwizzle.b;
+            break;
+	    case SWIZZLE_A:
+            output = colorToSwizzle.a;
+            break;
+		default:
+            break;
+    }
+}
+
+float4 PS(PS_Input input) : SV_Target0
+{
+    float4 outputColor;
+
+    if (Mode == 0)
+    {
+        //float4 color = Texture.SampleLevel(Sampler, float3(input.Texcoord, ArraySlice), MipLevel);
+        // Quasi next neighbor
+        float4 color = Texture.Load(int4(input.Texcoord * Texels, ArraySlice, MipLevel));
+        outputColor = float4(ColorOffset.xxx, AlphaOffset) + color * float4(ColorScale.xxx, AlphaScale);
+    }
+    else if (Mode == 1)
+    {
+        int4 color = IntTexture.Load(int4(input.Texcoord * Texels, ArraySlice, MipLevel));
+        outputColor = float4(ColorOffset.xxx, AlphaOffset) + color * float4(ColorScale.xxx, AlphaScale);
+    }
+    else if (Mode == 2)
+    {
+        uint4 color = UIntTexture.Load(int4(input.Texcoord * Texels, ArraySlice, MipLevel));
+        outputColor = float4(ColorOffset.xxx, AlphaOffset) + color * float4(ColorScale.xxx, AlphaScale);
+    }
+
+    float4 swizzledOutput = float4(0, 0, 0, 1);
+
+    SwizzleColor(Swizzle.r, outputColor, swizzledOutput.r);
+    SwizzleColor(Swizzle.g, outputColor, swizzledOutput.g);
+    SwizzleColor(Swizzle.b, outputColor, swizzledOutput.b);
+    SwizzleColor(Swizzle.a, outputColor, swizzledOutput.a);
+
+    return swizzledOutput;
+}
+
+#pragma Effect[VS=VS; PS=PS]

GlitchyEditor/resources/Shaders/RenderTargetGroupViewer.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}/* No reflection data for GlitchyEditor.Assets.EffectAssetLoaderConfig. Add [BonTarget] or force it */
+}

GlitchyEditor/resources/Shaders/ShaderHelpers.hlsl

@@ -0,0 +1,90 @@
+#ifndef __SHADER_HELPERS_HLSL__
+#define __SHADER_HELPERS_HLSL__
+
+#define PI 3.14159265358979323846f
+
+/*
+* Calculates the weighted sum of two normal vectors.
+* nrm1: The first normal vector
+* nrm2: The second normal vector
+* a: The weight factor for nrm1
+* b: The weight factor for nrm2
+*/
+float3 BlendNormals(float3 nrm1, float3 nrm2, float a, float b)
+{    
+    return normalize(float3(a * nrm1.x / nrm1.z + b * nrm2.x / nrm2.z, 
+         a * nrm1.y / nrm1.z + b * nrm2.y / nrm2.z, 
+         1.0f));
+}
+
+/*
+* Scales a normal vector by a factor where 0 results in the vector (0, 0, 1)
+* nrm: The normal vector
+* a: The scaling factor
+*/
+float3 ScaleNormal(float3 nrm1, float a)
+{    
+    return normalize(float3(a * nrm1.x / nrm1.z, 
+         a * nrm1.y / nrm1.z, 
+         1.0f));
+}
+
+/*
+* Scales a normal vector by a factor where 0 results in the vector (0, 0, 1)
+* nrm: The normal vector
+* a: The scaling factor
+*/
+float3 ScaleNormal(float3 nrm1, float2 a)
+{
+    return normalize(float3(a.x * nrm1.x / nrm1.z,
+							a.y * nrm1.y / nrm1.z,
+							1.0f));
+}
+
+/*
+* Reconstructs the z-component of a normalized normal vector from a two-component value
+* cnrm: The x- and y-components of a normalized normal vector
+*/
+float3 DecompressNormal(float2 cnrm)
+{
+    return float3(cnrm, sqrt(1.0 - cnrm.x * cnrm.x - cnrm.y * cnrm.y));    
+}
+
+/*
+* Reconstructs the tangent space from a normal and a tangent
+* normal: The surface normal
+* tangent: The surface tangent
+* sigma: Defines the handedness of the tangent space matrix. 1.0 if it is right handend. -1.0 if it is left handed
+*/
+float3x3 ConstructTangentSpace(float3 normal, float3 tangent, float3 sigma)
+{
+    float3 n = normalize(normal);
+    float3 t = normalize(tangent - n * dot(tangent, n));
+    float3 b = cross(n, t) * sigma;
+    
+    return float3x3(t, b, n);
+}
+
+/**
+ * Calculates the luminance of an rgb-value.
+ * @param rgb The rgb color.
+ * @return The luminance of the given rgb color.
+ */
+float ColorToLuminance(float3 rgb)
+{
+    return rgb.r * 0.212639 + rgb.g * 0.715169 + rgb.b * 0.072192;    
+}
+
+/**
+ * Extrancts the handedness of the bitangent that is encoded in the z-component of the tangent.
+ * @param tangentz The z-component of the tangent with the handedness encoded.
+ * @return The handedness of the bitangent (bitangent = handedness * tangent x normal)
+ */
+float GetBitangentHandedness(float tangentz)
+{
+	// handedness is in least significant bit of tangent.z
+    uint z = asuint(tangentz);
+    return (z & 1) > 0 ? 1.0 : -1.0;
+}
+
+#endif // __SHADER_HELPERS_HLSL__

GlitchyEditor/resources/Shaders/ShaderHelpers.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}

GlitchyEditor/resources/Shaders/SimpleTonemapping.hlsl

@@ -0,0 +1,39 @@
+#include "ACES.hlsl"
+
+Texture2D CameraTarget : register(t0);
+SamplerState CameraTargetSampler : register(s0);
+
+struct VS_IN
+{
+	float2 Position : POSITION;
+	float2 TexCoord : TEXCOORD0;
+};
+
+struct PS_IN
+{
+	float4 Position : SV_POSITION;
+	float2 TexCoord : TEXCOORD;
+};
+
+PS_IN VS(VS_IN input)
+{
+	PS_IN output;
+
+	output.Position = float4(input.Position, 0, 1);
+	output.TexCoord = input.TexCoord;
+
+	return output;
+}
+
+float4 PS(PS_IN input) : SV_TARGET
+{
+	float4 rawColor = CameraTarget.Sample(CameraTargetSampler, input.TexCoord);
+
+	// float3 color = rawColor.rgb / (rawColor.rgb + 1.0f);
+
+	float3 color = ACESFitted(rawColor.rgb);
+	
+	return float4(color, 1);
+}
+
+#pragma Effect[VS = VS; PS = PS]

GlitchyEditor/resources/Shaders/SimpleTonemapping.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}

GlitchyEditor/resources/Shaders/circlebatch.hlsl

@@ -0,0 +1,88 @@
+#define EDITOR
+
+Texture2D Texture : register(t0);
+SamplerState Sampler : register(s0);
+
+cbuffer Constants : register(b0)
+{
+    float4x4 ViewProjection;
+};
+
+struct VS_Input
+{
+    float2 Position     : POSITION;
+    float2 Texcoord     : TEXCOORD0;
+    float4x4 Transform  : TRANSFORM;
+    float4 Color        : COLOR;
+    float4 UVTransform  : TEXCOORD1;
+    float InnerRadius   : TEXCOORD2;
+#ifdef EDITOR
+    uint EntityId : ENTITYID;
+#endif
+};
+
+struct PS_Input
+{
+    float4 Position     : SV_Position;
+    float2 RawPos       : TEXCOORD0;
+    float2 Texcoord     : TEXCOORD1;
+    float4 Color        : COLOR;
+#ifdef EDITOR
+    nointerpolation uint EntityId : ENTITYID;
+#endif
+    float InnerRadius   : TEXCOORD2;
+};
+
+PS_Input VS(VS_Input input)
+{
+    PS_Input output;
+
+    output.Position = mul(ViewProjection, mul(input.Transform, float4(input.Position, 0.0f, 1.0f)));
+    output.Texcoord = input.UVTransform.xy + input.UVTransform.zw * input.Texcoord;
+    output.RawPos = input.Position;
+    output.Color = input.Color;
+    output.InnerRadius = input.InnerRadius;
+
+#ifdef EDITOR
+    output.EntityId = input.EntityId;
+#endif
+
+    return output;
+}
+
+struct PS_Output
+{
+    float4 Color : SV_Target0;
+#ifdef EDITOR
+    uint EntityId : SV_TARGET1;
+#endif
+};
+
+PS_Output PS(PS_Input input)
+{
+    PS_Output output;
+
+    float2 uv = input.RawPos * 2;
+
+    float distance = 1.0f - length(uv);
+
+    // Smoothing edges based on derivative (not sure if RawPos is the best value for this)
+    float f = fwidth(input.RawPos.x) + fwidth(input.RawPos.y);
+
+    float amount = smoothstep(0.0f, f, distance);
+    amount *= smoothstep(input.InnerRadius + f, input.InnerRadius, distance);
+
+    // Discard invisible pixels
+    clip(amount - 0.5f);
+
+    output.Color = Texture.Sample(Sampler, input.Texcoord) * input.Color;
+    output.Color.a *= amount;
+
+#ifdef EDITOR
+    output.EntityId = input.EntityId;
+#endif
+
+    return output;
+}
+
+#pragma Effect[VS=VS; PS=PS]

GlitchyEditor/resources/Shaders/circlebatch.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}

GlitchyEditor/resources/Shaders/lineShader.hlsl

@@ -0,0 +1,31 @@
+cbuffer Constants : register(b0)
+{
+    float4x4 ViewProjection;
+    float4 Color;
+};
+
+struct VS_Input
+{
+    float4 Position : POSITION;
+};
+
+struct PS_Input
+{
+    float4 Position : SV_Position;
+};
+
+PS_Input VS(VS_Input input)
+{
+    PS_Input output;
+
+    output.Position = mul(ViewProjection, input.Position);
+
+    return output;
+}
+
+float4 PS(PS_Input input) : SV_Target0
+{
+    return Color;
+}
+
+#pragma Effect[VS=VS; PS=PS]

GlitchyEditor/resources/Shaders/lineShader.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}

GlitchyEditor/resources/Shaders/linebatch.hlsl

@@ -0,0 +1,61 @@
+#define EDITOR
+
+cbuffer Constants : register(b0)
+{
+    float4x4 ViewProjection;
+};
+
+struct VS_Input
+{
+    float4 Position : POSITION;
+    float4 Color    : COLOR;
+#ifdef EDITOR
+    uint EntityId   : ENTITYID;
+#endif
+};
+
+typedef struct PS_Input
+{
+    float4 Position : SV_Position;
+    float4 Color    : COLOR;
+#ifdef EDITOR
+    nointerpolation uint EntityId : ENTITYID;
+#endif
+} VS_Output;
+
+VS_Output VS(VS_Input input)
+{
+    VS_Output output;
+
+    output.Position = mul(ViewProjection, input.Position);
+    output.Color = input.Color;
+
+#ifdef EDITOR
+    output.EntityId = input.EntityId;
+#endif
+
+    return output;
+}
+
+struct PS_Output
+{
+    float4 Color : SV_TARGET0;
+#ifdef EDITOR
+    uint EntityId : SV_TARGET1;
+#endif
+};
+
+PS_Output PS(PS_Input input)
+{
+    PS_Output output;
+
+    output.Color = input.Color;
+
+#ifdef EDITOR
+    output.EntityId = input.EntityId;
+#endif
+
+    return output;
+}
+
+#pragma Effect[VS=VS; PS=PS]

GlitchyEditor/resources/Shaders/linebatch.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}/* No reflection data for GlitchyEditor.Assets.EffectAssetLoaderConfig. Add [BonTarget] or force it */
+}

GlitchyEditor/resources/Shaders/msdfShader.hlsl

@@ -0,0 +1,93 @@
+Texture2D<float3> Texture : register(t0);
+SamplerState Sampler : register(s0);
+
+cbuffer Constants
+{
+    float4x4 ViewProjection;
+    float2 UnitRange;
+    float screenPixelRange = 2;
+}
+
+struct VS_Input
+{
+    float2 Position    : POSITION;
+    float2 Texcoord    : TEXCOORD0;
+    float4x4 Tranform  : TRANSFORM;
+    float4 Color       : COLOR;
+    float4 UVTransform : TEXCOORD1;
+};
+
+struct PS_Input
+{
+    float4 Position : SV_Position;
+    float2 TexCoord : TEXCOORD0;
+    float4 Color    : COLOR;
+};
+
+PS_Input VS(VS_Input input)
+{
+    PS_Input output;
+
+    output.Position = mul(ViewProjection, mul(input.Tranform, float4(input.Position, 0.0f, 1.0f)));
+    output.TexCoord = input.UVTransform.xy + input.UVTransform.zw * input.Texcoord;
+    output.Color = input.Color;
+
+    return output;
+}
+
+/*
+in vec2 texCoord;
+out vec4 color;
+uniform sampler2D msdf;
+uniform vec4 bgColor;
+uniform vec4 fgColor;
+
+float median(float r, float g, float b) {
+    return max(min(r, g), min(max(r, g), b));
+}
+
+void main() {
+    vec3 msd = texture(msdf, texCoord).rgb;
+    float sd = median(msd.r, msd.g, msd.b);
+    float screenPxDistance = screenPxRange()*(sd - 0.5);
+    float opacity = clamp(screenPxDistance + 0.5, 0.0, 1.0);
+    color = mix(bgColor, fgColor, opacity);
+}
+*/
+
+
+float median(float r, float g, float b)
+{
+    return max(min(r, g), min(max(r, g), b));
+}
+
+float ScreenPxRange(float2 texcoord)
+{
+    float2 screenTexSize = 1.0f / fwidth(texcoord);
+    return max(0.5f * dot(UnitRange, screenTexSize), 1.0f);
+}
+
+float4 PS(PS_Input input) : SV_Target0
+{
+    float3 msd = Texture.Sample(Sampler, input.TexCoord);
+    float sd = median(msd.r, msd.g, msd.b);
+    float screenPxDistance = ScreenPxRange(input.TexCoord) * (sd - 0.5);
+    float opacity = clamp(screenPxDistance + 0.5, 0.0, 1.0);
+
+    return float4(input.Color.rgb, opacity * input.Color.a);
+}
+
+/*
+// 2D
+float4 PS(PS_Input input) : SV_Target0
+{
+    float3 msd = Texture.Sample(Sampler, input.TexCoord).rgb;
+    float sd = median(msd.r, msd.g, msd.b);
+    float screenPxDistance = screenPixelRange*(sd - 0.5);
+    float opacity = clamp(screenPxDistance + 0.5, 0.0, 1.0);
+
+    return float4(input.Color.rgb, opacity * input.Color.a);
+}
+*/
+
+#pragma Effect[VS=VS; PS=PS]

GlitchyEditor/resources/Shaders/msdfShader.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}

GlitchyEditor/resources/Shaders/myEffect.hlsl

@@ -0,0 +1,152 @@
+#define OutputEntityId
+
+#include "ShaderHelpers.hlsl"
+
+#include "GlitchyEngine.hlsl"
+
+Texture2D AlbedoTexture : register(t0);
+SamplerState AlbedoSampler : register(s0);
+
+Texture2D<float3> NormalTexture : register(t1);
+SamplerState NormalSampler : register(s1);
+
+Texture2D<float> MetallicTexture : register(t2);
+SamplerState MetallicSampler : register(s2);
+
+Texture2D<float> RoughnessTexture : register(t3);
+SamplerState RoughnessSampler : register(s3);
+
+Texture2D<float3> EmissiveTexture : register(t4);
+SamplerState EmissiveSampler : register(s4);
+
+// Texture2D<float> AmbientTexture : register(t5);
+// SamplerState AmbientSampler : register(s5);
+
+cbuffer MaterialConstants : register(b2)
+{
+    #pragma EditorVariable[ Name = "AlbedoColor"; Preview = "Albedo Color"; Type="Color" ]
+    float4 AlbedoColor = float4(1.0, 1.0, 1.0, 1.0);
+    #pragma EditorVariable[ Name = "NormalScaling"; Preview = "Normal Scaling" ]
+    float2 NormalScaling = float2(1.0, 1.0);
+    #pragma EditorVariable[ Name = "MetallicFactor"; Preview = "Metallic Factor"; Min = 0.0f; Max = 1.0f ]
+    float MetallicFactor = 0.0;
+    #pragma EditorVariable[ Name = "RoughnessFactor"; Preview = "Rougness Factor"; Min = 0.0f; Max = 1.0f ]
+    float RoughnessFactor = 0.6;
+    #pragma EditorVariable[ Name = "EmissiveColor"; Preview = "Emissive Factor"; Type="ColorHDR" ]
+    float3 EmissiveColor = float3(0.0, 0.0, 0.0);
+    // # pra gma Editor Variable[ Name = "AmbientFactor"; Preview = "Ambient Factor" ]
+    // float AmbientFactor = 1.0;
+}
+
+struct VS_IN
+{
+    float3 Position     : POSITION;
+    float3 Normal       : NORMAL;
+    // Todo: Tangent.w... handedness
+	float3 Tangent      : TANGENT;
+	float2 TexCoord     : TEXCOORD;
+};
+
+typedef struct PS_IN
+{
+    float4 Position      : SV_POSITION;
+    float3 WorldPosition : WORLDPOSITION;
+    float3 Normal        : NORMAL;
+	float3 Tangent       : TANGENT;
+	float2 TexCoord      : TEXCOORD;
+	//nointerpolation float Handedness : HANDEDNESS;
+#ifdef OutputEntityId
+    nointerpolation uint EntityId : ENTITYID;
+#endif
+} VS_OUT;
+
+VS_OUT VS(VS_IN input)
+{
+    VS_OUT output;
+	
+	float4 worldPosition = mul(Transform, float4(input.Position, 1));
+	
+	output.Position = mul(ViewProjection, worldPosition);
+    output.WorldPosition = worldPosition.xyz / worldPosition.w;
+
+    output.Normal = mul(Transform_InvT, input.Normal);
+	output.Tangent = mul((float3x3)Transform, input.Tangent);
+	// TODO: output.Handedness = input.Tangent.w
+
+	output.TexCoord = input.TexCoord;
+
+    output.EntityId = EntityId;
+    
+    return output;
+}
+
+//struct PS_OUT
+//{
+//    float4 Albedo   : SV_TARGET0;
+//    // RG: TextureNormal.XY BA: GeoNrm.XY
+//    float4 Normal   : SV_TARGET1;
+//    // R: GeoNrm.Z GBA: GeoTan.XYZ
+//    float4 Tangent   : SV_TARGET2;
+//    float4 Position : SV_TARGET3;
+//    // R: Metallicity G: Roughness B: Ambient
+//    float4 Material : SV_TARGET4;
+//#ifdef OutputEntityId
+//    uint EntityId : SV_TARGET5;
+//#endif
+//};
+
+PS_OUT_Lit PS(PS_IN input)
+{
+    // Build tangent space
+    float3 normal = normalize(input.Normal);
+    float3 tangent = normalize(input.Tangent - dot(input.Tangent, normal) * input.Normal);
+    // TODO: float3 bitangent = input.Handedness * cross(normal, tangent);
+    float3 bitangent = -cross(normal, tangent);
+
+    //float3x3 tangentTransform = float3x3(tangent, bitangent, normal);
+    //tangentTransform = transpose(tangentTransform);
+
+    float4 texAlbedo = AlbedoTexture.Sample(AlbedoSampler, input.TexCoord);
+    float3 texNormal = NormalTexture.Sample(NormalSampler, input.TexCoord);
+    texNormal.xy = texNormal.xy * 2.0 - 1.0;
+    float texMetallic = MetallicTexture.Sample(MetallicSampler, input.TexCoord);
+    float texRoughness = RoughnessTexture.Sample(RoughnessSampler, input.TexCoord);
+
+    
+    float3 texEmissive = EmissiveTexture.Sample(EmissiveSampler, input.TexCoord);
+
+    //float3 objectNormal = mul(tangentTransform, texNormal);
+    //float3 worldNormal = mul(objectNormal, (float3x3)Transform);
+
+    float4 finalAlbedo = texAlbedo * AlbedoColor;
+    float3 finalNormal = ScaleNormal(texNormal, NormalScaling);
+    float finalMetallic = texMetallic * MetallicFactor;
+    float finalRoughness = texRoughness * RoughnessFactor;
+    float3 finalEmissive = texEmissive * EmissiveColor;
+
+/////////////TODO: REMOVEME
+
+	//worldNormal = max(worldNormal - 10000000, normal);
+	//texAlbedo = max(texAlbedo - 10000000, 1.0);
+	//texMetallic = max(texMetallic - 10000000, 0.0);
+	//texRoughness = max(texRoughness - 10000000, 0.1);
+
+/////////////TODO: END_REMOVEME
+
+    PS_OUT_Lit output;
+    output.Albedo = finalAlbedo;
+    //output.Normal = float4(objectNormal, 1.0);
+    output.Normal = float4(finalNormal.xy, normal.xy);
+    output.Tangent = float4(normal.z, tangent.xyz);
+	output.Position = float4(input.WorldPosition, 1.0);
+    output.Emissive = float4(finalEmissive, 0.0);
+    output.Material = float4(finalMetallic, finalRoughness, 1.0, 0);
+
+#ifdef OutputEntityId
+    output.EntityId = input.EntityId;
+#endif
+
+    return output;
+}
+
+#pragma Effect[VS = VS; PS = PS]

GlitchyEditor/resources/Shaders/myEffect.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}

GlitchyEditor/resources/Shaders/simpleLight.hlsl

@@ -0,0 +1,128 @@
+#include "ShaderHelpers.hlsl"
+#include "PBR.hlsl"
+
+#define Render						0
+#define Inspect_NormalDistribution	1
+#define Inspect_GeometryFunction	2
+#define Inspect_Fresnel				3
+#define Inspect_Normal				4
+
+#define OUTPUT Render
+
+SamplerState Sampler : register(s0);
+
+Texture2D GBuffer_Albedo : register(t0);
+Texture2D GBuffer_Normal : register(t1);
+Texture2D GBuffer_Tangent : register(t2);
+Texture2D GBuffer_Position : register(t3);
+Texture2D GBuffer_Emissive : register(t4);
+Texture2D GBuffer_Material : register(t5);
+
+cbuffer Constants
+{
+	float3 CameraPos;
+	float2 Scaling;
+}
+
+cbuffer LightConstants
+{
+	float3 LightColor;
+    float Illuminance;
+    float3 LightDir;
+}
+
+struct VS_IN
+{
+    float2 Position : POSITION;
+    float2 TexCoord : TEXCOORD0;
+};
+
+struct PS_IN
+{
+    float4 Position : SV_POSITION;
+    float2 TexCoord : TEXCOORD;
+};
+
+PS_IN VS(VS_IN input)
+{
+    PS_IN output;
+	
+    output.Position = float4(input.Position, 0, 1);
+    output.TexCoord = input.TexCoord * Scaling;
+    
+    return output;
+}
+
+float4 PS(PS_IN input) : SV_TARGET
+{
+    // Load Data from GBuffer
+    float4 rawAlbedo = GBuffer_Albedo.Sample(Sampler, input.TexCoord);
+	float4 rawNormal = GBuffer_Normal.Sample(Sampler, input.TexCoord);
+	float4 rawTangent = GBuffer_Tangent.Sample(Sampler, input.TexCoord);
+    float4 rawPosition = GBuffer_Position.Sample(Sampler, input.TexCoord);
+    float4 rawEmissive = GBuffer_Emissive.Sample(Sampler, input.TexCoord);
+	float4 rawMaterial = GBuffer_Material.Sample(Sampler, input.TexCoord);
+
+	// Extract data from GBuffer
+	float3 albedo = rawAlbedo.rgb;
+    //float3 surfaceNormal = normalize(rawNormal.xyz);
+    float3 worldPosition = rawPosition.xyz;
+
+    float metallic = rawMaterial.r;
+    float roughness = rawMaterial.g;
+
+	float3 textureNormal = DecompressNormal(rawNormal.rg);
+	float3 rawGeoNrm = float3(rawNormal.ba, rawTangent.r);
+	float3 rawGeoTan = rawTangent.gba;
+
+	// Reconstruct normal space
+	float3 normal = normalize(rawGeoNrm);
+	float3 tangent = normalize(rawGeoTan - dot(rawGeoTan, normal) * normal);
+	float3 bitangent = -cross(normal, tangent);
+
+	float3x3 tangentTransform = float3x3(tangent, bitangent, normal);
+
+	float3 surfaceNormal = mul(textureNormal, tangentTransform);
+	
+	float3 lightDir = normalize(LightDir);
+	float3 viewDir = normalize(CameraPos - worldPosition.xyz);
+	float3 halfway = normalize(lightDir + viewDir);
+
+	float n_dot_v = max(dot(surfaceNormal, viewDir), 0.0f);
+	float n_dot_h = max(dot(surfaceNormal, halfway), 0.0f);
+	float n_dot_l = max(dot(surfaceNormal, lightDir), 0.0f);
+
+	float nrmDist = NormalDistributionGGX(surfaceNormal, halfway, roughness);
+	float geo = GeometrySmith(surfaceNormal, viewDir, lightDir, roughness);
+
+	float3 F0 = 0.04f;
+	F0 = lerp(F0, albedo, metallic);
+	float3 fresnel = FresnelSchlick(n_dot_h, F0);
+	
+	float3 ks = fresnel;
+	float3 kd = 1.0f - ks;
+
+	// Metals have no diffuse light
+	kd *= 1.0f - metallic;
+
+	float3 diffuse = albedo / PI;
+	float3 specular = (nrmDist * fresnel * geo) / max(4 * n_dot_v * n_dot_l, 0.0001f);
+
+	float3 luminanceColor = LightColor * Illuminance;
+
+    float3 final = (kd * diffuse + specular) * luminanceColor * n_dot_l + rawEmissive;
+	
+#if OUTPUT == Inspect_NormalDistribution
+		final = max(final - 10000000, nrmDist.xxx);
+#elif OUTPUT == Inspect_GeometryFunction
+		final = max(final - 10000000, geo.xxx);
+#elif OUTPUT == Inspect_Fresnel
+		final = max(final - 10000000, fresnel);
+#elif OUTPUT == Inspect_Normal
+		final = max(final - 10000000, surfaceNormal / 2 + 0.5f);
+#endif
+
+	return float4(final, 1);
+}
+
+#pragma Effect[VS = VS; PS = PS]

GlitchyEditor/resources/Shaders/simpleLight.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}

GlitchyEditor/resources/Shaders/spritebatch.hlsl

@@ -0,0 +1,74 @@
+#define EDITOR
+
+Texture2D Texture : register(t0);
+SamplerState Sampler : register(s0);
+
+cbuffer Constants : register(b0)
+{
+    float4x4 ViewProjection;
+};
+
+struct VS_Input
+{
+    float2 Position     : POSITION;
+    float2 Texcoord     : TEXCOORD0;
+    float4x4 Transform  : TRANSFORM;
+    float4 Color        : COLOR;
+    float4 UVTransform  : TEXCOORD1;
+#ifdef EDITOR
+    uint EntityId : ENTITYID;
+#endif
+};
+
+struct PS_Input
+{
+    float4 Position : SV_Position;
+    float2 Texcoord : TEXCOORD;
+    float4 Color    : COLOR;
+#ifdef EDITOR
+    nointerpolation uint EntityId : ENTITYID;
+#endif
+};
+
+PS_Input VS(VS_Input input)
+{
+    PS_Input output;
+
+    output.Position = mul(ViewProjection, mul(input.Transform, float4(input.Position, 0.0f, 1.0f)));
+    output.Texcoord = input.UVTransform.xy + input.UVTransform.zw * input.Texcoord;
+    output.Color = input.Color;
+
+    // Premultiply Alpha
+    output.Color.rgb *= output.Color.a;
+
+#ifdef EDITOR
+    output.EntityId = input.EntityId;
+#endif
+
+    return output;
+}
+
+struct PS_Output
+{
+    float4 Color : SV_Target0;
+#ifdef EDITOR
+    uint EntityId : SV_TARGET1;
+#endif
+};
+
+PS_Output PS(PS_Input input)
+{
+    PS_Output output;
+
+    output.Color = Texture.Sample(Sampler, input.Texcoord) * input.Color;
+    
+    clip(output.Color.a - 0.001f);
+
+#ifdef EDITOR
+    output.EntityId = input.EntityId;
+#endif
+
+    return output;
+}
+
+#pragma Effect[VS = VS; PS = PS]

GlitchyEditor/resources/Shaders/spritebatch.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}

GlitchyEditor/resources/Shaders/textureViewerShader.hlsl

@@ -0,0 +1,52 @@
+Texture2D Texture : register(t0);
+SamplerState Sampler : register(s0);
+
+cbuffer Constants
+{
+    float4x4 ViewProjection;
+
+    float ColorOffset = 0.5f;
+    float AlphaOffset = 0.0f;
+    float ColorScale = 0.5f;
+    float AlphaScale = 1.0f;
+
+    float2 TextureSizeInPixels;
+}
+
+struct VS_Input
+{
+    float2 Position     : POSITION;
+    float2 Texcoord     : TEXCOORD0;
+    float4x4 Transform  : TRANSFORM;
+    float4 Color        : COLOR;
+    float4 UVTransform  : TEXCOORD1;
+};
+
+struct PS_Input
+{
+    float4 Position : SV_Position;
+    float2 Texcoord : TEXCOORD0;
+    float4 Color : COLOR;
+};
+
+PS_Input VS(VS_Input input)
+{
+    PS_Input output;
+
+    output.Position = mul(ViewProjection, mul(input.Transform, float4(input.Position, 0.0f, 1.0f)));
+    output.Texcoord = input.UVTransform.xy + input.UVTransform.zw * input.Texcoord;
+    output.Color = input.Color;
+
+    return output;
+}
+
+float4 PS(PS_Input input) : SV_Target0
+{
+    float4 color = Texture.Sample(Sampler, input.Texcoord);
+
+    float4 final = float4(ColorOffset.xxx, AlphaOffset) + color * float4(ColorScale.xxx, AlphaScale);
+
+    return final;
+}
+
+#pragma Effect[VS=VS; PS=PS]

GlitchyEditor/resources/Shaders/textureViewerShader.hlsl.ass

@@ -0,0 +1,4 @@
+{
+	AssetLoader = "EffectAssetLoader",
+	Config = (GlitchyEditor.Assets.EffectAssetLoaderConfig){}
+}