add scene render system, add proper HDR environments, try load texture from mesh file

Editor/assets/models/m1911/imgui.ini

@@ -0,0 +1,71 @@
+[Window][DockSpace Demo]
+Pos=0,0
+Size=2560,1387
+Collapsed=0
+
+[Window][Debug##Default]
+Pos=55,90
+Size=400,400
+Collapsed=0
+
+[Window][Renderer]
+Pos=2047,1141
+Size=285,134
+Collapsed=0
+
+[Window][Model]
+Pos=1772,24
+Size=788,577
+Collapsed=0
+DockId=0x00000001,0
+
+[Window][Environment]
+Pos=1772,603
+Size=788,784
+Collapsed=0
+DockId=0x00000002,0
+
+[Window][Viewport]
+Pos=421,24
+Size=1349,1363
+Collapsed=0
+DockId=0x00000003,0
+
+[Window][Mesh Debug]
+Pos=2055,471
+Size=505,916
+Collapsed=0
+DockId=0x00000002,1
+
+[Window][ImGui Demo]
+ViewportPos=276,66
+ViewportId=0x080FC883
+Size=1923,1168
+Collapsed=0
+
+[Window][Mesh Hierarchy]
+Pos=0,24
+Size=419,1363
+Collapsed=0
+DockId=0x00000005,1
+
+[Window][Scene Hierarchy]
+Pos=0,24
+Size=419,1363
+Collapsed=0
+DockId=0x00000005,0
+
+[Window][Properties]
+Pos=107,1086
+Size=188,127
+Collapsed=0
+
+[Docking][Data]
+DockSpace       ID=0xFA06BC56 Window=0x4647B76E Pos=0,47 Size=2560,1363 Split=X
+  DockNode      ID=0x00000005 Parent=0xFA06BC56 SizeRef=419,1363 Selected=0x9A68760C
+  DockNode      ID=0x00000006 Parent=0xFA06BC56 SizeRef=2139,1363 Split=X
+    DockNode    ID=0x00000003 Parent=0x00000006 SizeRef=1349,876 CentralNode=1 HiddenTabBar=1 Selected=0x995B0CF8
+    DockNode    ID=0x00000004 Parent=0x00000006 SizeRef=788,876 Split=Y Selected=0x16545DDD
+      DockNode  ID=0x00000001 Parent=0x00000004 SizeRef=705,577 Selected=0x16545DDD
+      DockNode  ID=0x00000002 Parent=0x00000004 SizeRef=705,784 Selected=0xC0BA51F5
+

Editor/assets/shaders/EnvironmentIrradiance.glsl

@@ -0,0 +1,103 @@
+#type compute
+#version 450 core
+// Physically Based Rendering
+// Copyright (c) 2017-2018 Michał Siejak
+
+// Computes diffuse irradiance cubemap convolution for image-based lighting.
+// Uses quasi Monte Carlo sampling with Hammersley sequence.
+
+const float PI = 3.141592;
+const float TwoPI = 2 * PI;
+const float Epsilon = 0.00001;
+
+const uint NumSamples = 64 * 1024;
+const float InvNumSamples = 1.0 / float(NumSamples);
+
+layout(binding=0) uniform samplerCube inputTexture;
+layout(binding=0, rgba16f) restrict writeonly uniform imageCube outputTexture;
+
+// Compute Van der Corput radical inverse
+// See: http://holger.dammertz.org/stuff/notes_HammersleyOnHemisphere.html
+float radicalInverse_VdC(uint bits)
+{
+	bits = (bits << 16u) | (bits >> 16u);
+	bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
+	bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
+	bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
+	bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
+	return float(bits) * 2.3283064365386963e-10; // / 0x100000000
+}
+
+// Sample i-th point from Hammersley point set of NumSamples points total.
+vec2 sampleHammersley(uint i)
+{
+	return vec2(i * InvNumSamples, radicalInverse_VdC(i));
+}
+
+// Uniformly sample point on a hemisphere.
+// Cosine-weighted sampling would be a better fit for Lambertian BRDF but since this
+// compute shader runs only once as a pre-processing step performance is not *that* important.
+// See: "Physically Based Rendering" 2nd ed., section 13.6.1.
+vec3 sampleHemisphere(float u1, float u2)
+{
+	const float u1p = sqrt(max(0.0, 1.0 - u1*u1));
+	return vec3(cos(TwoPI*u2) * u1p, sin(TwoPI*u2) * u1p, u1);
+}
+
+vec3 GetCubeMapTexCoord()
+{
+    vec2 st = gl_GlobalInvocationID.xy / vec2(imageSize(outputTexture));
+    vec2 uv = 2.0 * vec2(st.x, 1.0 - st.y) - vec2(1.0);
+
+    vec3 ret;
+    if (gl_GlobalInvocationID.z == 0)      ret = vec3(  1.0, uv.y, -uv.x);
+    else if (gl_GlobalInvocationID.z == 1) ret = vec3( -1.0, uv.y,  uv.x);
+    else if (gl_GlobalInvocationID.z == 2) ret = vec3( uv.x,  1.0, -uv.y);
+    else if (gl_GlobalInvocationID.z == 3) ret = vec3( uv.x, -1.0,  uv.y);
+    else if (gl_GlobalInvocationID.z == 4) ret = vec3( uv.x, uv.y,   1.0);
+    else if (gl_GlobalInvocationID.z == 5) ret = vec3(-uv.x, uv.y,  -1.0);
+    return normalize(ret);
+}
+
+// Compute orthonormal basis for converting from tanget/shading space to world space.
+void computeBasisVectors(const vec3 N, out vec3 S, out vec3 T)
+{
+	// Branchless select non-degenerate T.
+	T = cross(N, vec3(0.0, 1.0, 0.0));
+	T = mix(cross(N, vec3(1.0, 0.0, 0.0)), T, step(Epsilon, dot(T, T)));
+
+	T = normalize(T);
+	S = normalize(cross(N, T));
+}
+
+// Convert point from tangent/shading space to world space.
+vec3 tangentToWorld(const vec3 v, const vec3 N, const vec3 S, const vec3 T)
+{
+	return S * v.x + T * v.y + N * v.z;
+}
+
+layout(local_size_x=32, local_size_y=32, local_size_z=1) in;
+void main(void)
+{
+	vec3 N = GetCubeMapTexCoord();
+	
+	vec3 S, T;
+	computeBasisVectors(N, S, T);
+
+	// Monte Carlo integration of hemispherical irradiance.
+	// As a small optimization this also includes Lambertian BRDF assuming perfectly white surface (albedo of 1.0)
+	// so we don't need to normalize in PBR fragment shader (so technically it encodes exitant radiance rather than irradiance).
+	vec3 irradiance = vec3(0);
+	for(uint i = 0; i < NumSamples; i++)
+	{
+		vec2 u  = sampleHammersley(i);
+		vec3 Li = tangentToWorld(sampleHemisphere(u.x, u.y), N, S, T);
+		float cosTheta = max(0.0, dot(Li, N));
+
+		// PIs here cancel out because of division by pdf.
+		irradiance += 2.0 * textureLod(inputTexture, Li, 0).rgb * cosTheta;
+	}
+	irradiance /= vec3(NumSamples);
+
+	imageStore(outputTexture, ivec3(gl_GlobalInvocationID), vec4(irradiance, 1.0));
+}

Editor/assets/shaders/EnvironmentMipFilter.glsl

@@ -0,0 +1,159 @@
+#type compute
+#version 450 core
+// Physically Based Rendering
+// Copyright (c) 2017-2018 Michał Siejak
+
+// Pre-filters environment cube map using GGX NDF importance sampling.
+// Part of specular IBL split-sum approximation.
+
+const float PI = 3.141592;
+const float TwoPI = 2 * PI;
+const float Epsilon = 0.00001;
+
+const uint NumSamples = 1024;
+const float InvNumSamples = 1.0 / float(NumSamples);
+
+const int NumMipLevels = 1;
+layout(binding = 0) uniform samplerCube inputTexture;
+layout(binding = 0, rgba16f) restrict writeonly uniform imageCube outputTexture[NumMipLevels];
+
+// Roughness value to pre-filter for.
+layout(location=0) uniform float roughness;
+
+#define PARAM_LEVEL     0
+#define PARAM_ROUGHNESS roughness
+
+// Compute Van der Corput radical inverse
+// See: http://holger.dammertz.org/stuff/notes_HammersleyOnHemisphere.html
+float radicalInverse_VdC(uint bits)
+{
+	bits = (bits << 16u) | (bits >> 16u);
+	bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
+	bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
+	bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
+	bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
+	return float(bits) * 2.3283064365386963e-10; // / 0x100000000
+}
+
+// Sample i-th point from Hammersley point set of NumSamples points total.
+vec2 sampleHammersley(uint i)
+{
+	return vec2(i * InvNumSamples, radicalInverse_VdC(i));
+}
+
+// Importance sample GGX normal distribution function for a fixed roughness value.
+// This returns normalized half-vector between Li & Lo.
+// For derivation see: http://blog.tobias-franke.eu/2014/03/30/notes_on_importance_sampling.html
+vec3 sampleGGX(float u1, float u2, float roughness)
+{
+	float alpha = roughness * roughness;
+
+	float cosTheta = sqrt((1.0 - u2) / (1.0 + (alpha*alpha - 1.0) * u2));
+	float sinTheta = sqrt(1.0 - cosTheta*cosTheta); // Trig. identity
+	float phi = TwoPI * u1;
+
+	// Convert to Cartesian upon return.
+	return vec3(sinTheta * cos(phi), sinTheta * sin(phi), cosTheta);
+}
+
+// GGX/Towbridge-Reitz normal distribution function.
+// Uses Disney's reparametrization of alpha = roughness^2.
+float ndfGGX(float cosLh, float roughness)
+{
+	float alpha   = roughness * roughness;
+	float alphaSq = alpha * alpha;
+
+	float denom = (cosLh * cosLh) * (alphaSq - 1.0) + 1.0;
+	return alphaSq / (PI * denom * denom);
+}
+
+vec3 GetCubeMapTexCoord()
+{
+    vec2 st = gl_GlobalInvocationID.xy / vec2(imageSize(outputTexture[PARAM_LEVEL]));
+    vec2 uv = 2.0 * vec2(st.x, 1.0 - st.y) - vec2(1.0);
+
+    vec3 ret;
+    if (gl_GlobalInvocationID.z == 0)      ret = vec3(  1.0, uv.y, -uv.x);
+    else if (gl_GlobalInvocationID.z == 1) ret = vec3( -1.0, uv.y,  uv.x);
+    else if (gl_GlobalInvocationID.z == 2) ret = vec3( uv.x,  1.0, -uv.y);
+    else if (gl_GlobalInvocationID.z == 3) ret = vec3( uv.x, -1.0,  uv.y);
+    else if (gl_GlobalInvocationID.z == 4) ret = vec3( uv.x, uv.y,   1.0);
+    else if (gl_GlobalInvocationID.z == 5) ret = vec3(-uv.x, uv.y,  -1.0);
+    return normalize(ret);
+}
+
+// Compute orthonormal basis for converting from tanget/shading space to world space.
+void computeBasisVectors(const vec3 N, out vec3 S, out vec3 T)
+{
+	// Branchless select non-degenerate T.
+	T = cross(N, vec3(0.0, 1.0, 0.0));
+	T = mix(cross(N, vec3(1.0, 0.0, 0.0)), T, step(Epsilon, dot(T, T)));
+
+	T = normalize(T);
+	S = normalize(cross(N, T));
+}
+
+// Convert point from tangent/shading space to world space.
+vec3 tangentToWorld(const vec3 v, const vec3 N, const vec3 S, const vec3 T)
+{
+	return S * v.x + T * v.y + N * v.z;
+}
+
+layout(local_size_x=32, local_size_y=32, local_size_z=1) in;
+void main(void)
+{
+	// Make sure we won't write past output when computing higher mipmap levels.
+	ivec2 outputSize = imageSize(outputTexture[PARAM_LEVEL]);
+	if(gl_GlobalInvocationID.x >= outputSize.x || gl_GlobalInvocationID.y >= outputSize.y) {
+		return;
+	}
+	
+	// Solid angle associated with a single cubemap texel at zero mipmap level.
+	// This will come in handy for importance sampling below.
+	vec2 inputSize = vec2(textureSize(inputTexture, 0));
+	float wt = 4.0 * PI / (6 * inputSize.x * inputSize.y);
+	
+	// Approximation: Assume zero viewing angle (isotropic reflections).
+	vec3 N = GetCubeMapTexCoord();
+	vec3 Lo = N;
+	
+	vec3 S, T;
+	computeBasisVectors(N, S, T);
+
+	vec3 color = vec3(0);
+	float weight = 0;
+
+	// Convolve environment map using GGX NDF importance sampling.
+	// Weight by cosine term since Epic claims it generally improves quality.
+	for(uint i = 0; i < NumSamples; i++) {
+		vec2 u = sampleHammersley(i);
+		vec3 Lh = tangentToWorld(sampleGGX(u.x, u.y, PARAM_ROUGHNESS), N, S, T);
+
+		// Compute incident direction (Li) by reflecting viewing direction (Lo) around half-vector (Lh).
+		vec3 Li = 2.0 * dot(Lo, Lh) * Lh - Lo;
+
+		float cosLi = dot(N, Li);
+		if(cosLi > 0.0) {
+			// Use Mipmap Filtered Importance Sampling to improve convergence.
+			// See: https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch20.html, section 20.4
+
+			float cosLh = max(dot(N, Lh), 0.0);
+
+			// GGX normal distribution function (D term) probability density function.
+			// Scaling by 1/4 is due to change of density in terms of Lh to Li (and since N=V, rest of the scaling factor cancels out).
+			float pdf = ndfGGX(cosLh, PARAM_ROUGHNESS) * 0.25;
+
+			// Solid angle associated with this sample.
+			float ws = 1.0 / (NumSamples * pdf);
+
+			// Mip level to sample from.
+			float mipLevel = max(0.5 * log2(ws / wt) + 1.0, 0.0);
+
+			color  += textureLod(inputTexture, Li, mipLevel).rgb * cosLi;
+			weight += cosLi;
+		}
+	}
+	color /= weight;
+
+	imageStore(outputTexture[PARAM_LEVEL], ivec3(gl_GlobalInvocationID), vec4(color, 1.0));
+}

Editor/assets/shaders/EquirectangularToCubeMap.glsl

@@ -0,0 +1,39 @@
+#type compute
+#version 450 core
+
+// Converts equirectangular (lat-long) projection texture into a cubemap
+
+const float PI = 3.141592;
+
+layout(binding = 0) uniform sampler2D u_EquirectangularTex;
+layout(binding = 0, rgba16f) restrict writeonly uniform imageCube o_CubeMap;
+
+vec3 GetCubeMapTexCoord()
+{
+    vec2 st = gl_GlobalInvocationID.xy / vec2(imageSize(o_CubeMap));
+    vec2 uv = 2.0 * vec2(st.x, 1.0 - st.y) - vec2(1.0);
+
+    vec3 ret;
+    if (gl_GlobalInvocationID.z == 0)      ret = vec3(  1.0, uv.y, -uv.x);
+    else if (gl_GlobalInvocationID.z == 1) ret = vec3( -1.0, uv.y,  uv.x);
+    else if (gl_GlobalInvocationID.z == 2) ret = vec3( uv.x,  1.0, -uv.y);
+    else if (gl_GlobalInvocationID.z == 3) ret = vec3( uv.x, -1.0,  uv.y);
+    else if (gl_GlobalInvocationID.z == 4) ret = vec3( uv.x, uv.y,   1.0);
+    else if (gl_GlobalInvocationID.z == 5) ret = vec3(-uv.x, uv.y,  -1.0);
+    return normalize(ret);
+}
+
+layout(local_size_x = 32, local_size_y = 32, local_size_z = 1) in;
+void main()
+{
+	vec3 cubeTC = GetCubeMapTexCoord();
+
+    // Calculate sampling coords for equirectangular texture
+	// https://en.wikipedia.org/wiki/Spherical_coordinate_system#Cartesian_coordinates
+	float phi = atan(cubeTC.z, cubeTC.x);
+	float theta = acos(cubeTC.y);
+    vec2 uv = vec2(phi / (2.0 * PI) + 0.5, theta / PI);
+
+	vec4 color = texture(u_EquirectangularTex, uv);
+	imageStore(o_CubeMap, ivec3(gl_GlobalInvocationID), color);
+}

Editor/assets/shaders/Grid.glsl

@@ -1,18 +1,19 @@
-// Simple Texture Shader
+// Grid Shader
 
 #type vertex
 #version 430
 
 layout(location = 0) in vec3 a_Position;
-layout(location = 4) in vec2 a_TexCoord;
+layout(location = 1) in vec2 a_TexCoord;
 
-uniform mat4 u_MVP;
+uniform mat4 u_ViewProjection;
+uniform mat4 u_Transform;
 
 out vec2 v_TexCoord;
 
 void main()
 {
-    vec4 position = u_MVP * vec4(a_Position, 1.0);
+	vec4 position = u_ViewProjection * u_Transform * vec4(a_Position, 1.0);
     gl_Position = position;
 
     v_TexCoord = a_TexCoord;
@@ -28,11 +29,6 @@ uniform float u_Res;
 
 in vec2 v_TexCoord;
 
-/*void main()
-{
-	color = texture(u_Texture, v_TexCoord * 8.0);
-}*/
-
 float grid(vec2 st, float res)
 {
     vec2 grid = fract(st);

Editor/assets/shaders/PBRShader_Anim.glsl

@@ -22,7 +22,7 @@ layout(location = 5) in ivec4 a_BoneIndices;
 layout(location = 6) in vec4 a_BoneWeights;
 
 uniform mat4 u_ViewProjectionMatrix;
-uniform mat4 u_ModelMatrix;
+uniform mat4 u_Transform;
 
 const int MAX_BONES = 100;
 uniform mat4 u_BoneTransforms[100];
@@ -38,21 +38,20 @@ out VertexOutput
 
 void main()
 {
-	mat4 boneTransform = u_BoneTransforms[a_BoneIndices[0]] * a_BoneWeights[0];
-	boneTransform += u_BoneTransforms[a_BoneIndices[1]] * a_BoneWeights[1];
-	boneTransform += u_BoneTransforms[a_BoneIndices[2]] * a_BoneWeights[2];
-	boneTransform += u_BoneTransforms[a_BoneIndices[3]] * a_BoneWeights[3];
+    mat4 boneTransform = u_BoneTransforms[a_BoneIndices[0]] * a_BoneWeights[0];
+    boneTransform += u_BoneTransforms[a_BoneIndices[1]] * a_BoneWeights[1];
+    boneTransform += u_BoneTransforms[a_BoneIndices[2]] * a_BoneWeights[2];
+    boneTransform += u_BoneTransforms[a_BoneIndices[3]] * a_BoneWeights[3];
 
 	vec4 localPosition = boneTransform * vec4(a_Position, 1.0);
 
-	vs_Output.WorldPosition = vec3(u_ModelMatrix * boneTransform * vec4(a_Position, 1.0));
-	vs_Output.Normal = mat3(boneTransform) * a_Normal;
+	vs_Output.WorldPosition = vec3(u_Transform * boneTransform * vec4(a_Position, 1.0));
+    vs_Output.Normal = mat3(boneTransform) * a_Normal;
 	vs_Output.TexCoord = vec2(a_TexCoord.x, 1.0 - a_TexCoord.y);
-	vs_Output.WorldNormals = mat3(u_ModelMatrix) * mat3(a_Tangent, a_Binormal, a_Normal);
+	vs_Output.WorldNormals = mat3(u_Transform) * mat3(a_Tangent, a_Binormal, a_Normal);
 	vs_Output.Binormal = mat3(boneTransform) * a_Binormal;
 
-	//gl_Position = u_ViewProjectionMatrix * u_ModelMatrix * vec4(a_Position, 1.0);
-	gl_Position = u_ViewProjectionMatrix * u_ModelMatrix * localPosition;
+	gl_Position = u_ViewProjectionMatrix * u_Transform * localPosition;
 }
 
 #type fragment
@@ -63,7 +62,6 @@ const float Epsilon = 0.00001;
 
 const int LightCount = 1;
 
-
 // Constant normal incidence Fresnel factor for all dielectrics.
 const vec3 Fdielectric = vec3(0.04);
 
@@ -290,12 +288,7 @@ vec3 IBL(vec3 F0, vec3 Lr)
 	int u_EnvRadianceTexLevels = textureQueryLevels(u_EnvRadianceTex);
 	float NoV = clamp(m_Params.NdotV, 0.0, 1.0);
 	vec3 R = 2.0 * dot(m_Params.View, m_Params.Normal) * m_Params.Normal - m_Params.View;
-	vec3 specularIrradiance = vec3(0.0);
-
-	if (u_RadiancePrefilter > 0.5)
-		specularIrradiance = PrefilterEnvMap(m_Params.Roughness * m_Params.Roughness, R) * u_RadiancePrefilter;
-	else
-		specularIrradiance = textureLod(u_EnvRadianceTex, RotateVectorAboutY(u_EnvMapRotation, Lr), sqrt(m_Params.Roughness) * u_EnvRadianceTexLevels).rgb * (1.0 - u_RadiancePrefilter);
+	vec3 specularIrradiance = textureLod(u_EnvRadianceTex, RotateVectorAboutY(u_EnvMapRotation, Lr), (m_Params.Roughness * m_Params.Roughness) * u_EnvRadianceTexLevels).rgb;
 
 	// Sample BRDF Lut, 1.0 - roughness for y-coord because texture was generated (in Sparky) for gloss model
 	vec2 specularBRDF = texture(u_BRDFLUTTexture, vec2(m_Params.NdotV, 1.0 - m_Params.Roughness)).rg;
@@ -329,7 +322,7 @@ void main()
 	// Fresnel reflectance, metals use albedo
 	vec3 F0 = mix(Fdielectric, m_Params.Albedo, m_Params.Metalness);
 
-	vec3 lightContribution = Lighting(F0);
+	vec3 lightContribution = vec3(0.0);//Lighting(F0);
 	vec3 iblContribution = IBL(F0, Lr);
 
 	color = vec4(lightContribution + iblContribution, 1.0);

Editor/assets/shaders/PBRShader_Static.glsl

@@ -0,0 +1,319 @@
+// -----------------------------
+// -- Hazel Engine PBR shader --
+// -----------------------------
+// Note: this shader is still very much in progress. There are likely many bugs and future additions that will go in.
+//       Currently heavily updated. 
+//
+// References upon which this is based:
+// - Unreal Engine 4 PBR notes (https://blog.selfshadow.com/publications/s2013-shading-course/karis/s2013_pbs_epic_notes_v2.pdf)
+// - Frostbite's SIGGRAPH 2014 paper (https://seblagarde.wordpress.com/2015/07/14/siggraph-2014-moving-frostbite-to-physically-based-rendering/)
+// - Michał Siejak's PBR project (https://github.com/Nadrin)
+// - My implementation from years ago in the Sparky engine (https://github.com/TheCherno/Sparky)
+#type vertex
+#version 430 core
+
+layout(location = 0) in vec3 a_Position;
+layout(location = 1) in vec3 a_Normal;
+layout(location = 2) in vec3 a_Tangent;
+layout(location = 3) in vec3 a_Binormal;
+layout(location = 4) in vec2 a_TexCoord;
+
+uniform mat4 u_ViewProjectionMatrix;
+uniform mat4 u_Transform;
+
+out VertexOutput
+{
+	vec3 WorldPosition;
+    vec3 Normal;
+	vec2 TexCoord;
+	mat3 WorldNormals;
+	mat3 WorldTransform;
+	vec3 Binormal;
+} vs_Output;
+
+void main()
+{
+	vs_Output.WorldPosition = vec3(u_Transform * vec4(a_Position, 1.0));
+    vs_Output.Normal = a_Normal;
+	vs_Output.TexCoord = vec2(a_TexCoord.x, 1.0 - a_TexCoord.y);
+	vs_Output.WorldNormals = mat3(u_Transform) * mat3(a_Tangent, a_Binormal, a_Normal);
+	vs_Output.WorldTransform = mat3(u_Transform);
+	vs_Output.Binormal = a_Binormal;
+
+	gl_Position = u_ViewProjectionMatrix * u_Transform * vec4(a_Position, 1.0);
+}
+
+#type fragment
+#version 430 core
+
+const float PI = 3.141592;
+const float Epsilon = 0.00001;
+
+const int LightCount = 1;
+
+// Constant normal incidence Fresnel factor for all dielectrics.
+const vec3 Fdielectric = vec3(0.04);
+
+struct Light {
+	vec3 Direction;
+	vec3 Radiance;
+};
+
+in VertexOutput
+{
+	vec3 WorldPosition;
+    vec3 Normal;
+	vec2 TexCoord;
+	mat3 WorldNormals;
+	mat3 WorldTransform;
+	vec3 Binormal;
+} vs_Input;
+
+layout(location = 0) out vec4 color;
+
+uniform Light lights;
+uniform vec3 u_CameraPosition;
+
+// PBR texture inputs
+uniform sampler2D u_AlbedoTexture;
+uniform sampler2D u_NormalTexture;
+uniform sampler2D u_MetalnessTexture;
+uniform sampler2D u_RoughnessTexture;
+
+// Environment maps
+uniform samplerCube u_EnvRadianceTex;
+uniform samplerCube u_EnvIrradianceTex;
+
+// BRDF LUT
+uniform sampler2D u_BRDFLUTTexture;
+
+uniform vec3 u_AlbedoColor;
+uniform float u_Metalness;
+uniform float u_Roughness;
+
+uniform float u_EnvMapRotation;
+
+// Toggles
+uniform float u_RadiancePrefilter;
+uniform float u_AlbedoTexToggle;
+uniform float u_NormalTexToggle;
+uniform float u_MetalnessTexToggle;
+uniform float u_RoughnessTexToggle;
+
+struct PBRParameters
+{
+	vec3 Albedo;
+	float Roughness;
+	float Metalness;
+
+	vec3 Normal;
+	vec3 View;
+	float NdotV;
+};
+
+PBRParameters m_Params;
+
+// GGX/Towbridge-Reitz normal distribution function.
+// Uses Disney's reparametrization of alpha = roughness^2
+float ndfGGX(float cosLh, float roughness)
+{
+	float alpha = roughness * roughness;
+	float alphaSq = alpha * alpha;
+
+	float denom = (cosLh * cosLh) * (alphaSq - 1.0) + 1.0;
+	return alphaSq / (PI * denom * denom);
+}
+
+// Single term for separable Schlick-GGX below.
+float gaSchlickG1(float cosTheta, float k)
+{
+	return cosTheta / (cosTheta * (1.0 - k) + k);
+}
+
+// Schlick-GGX approximation of geometric attenuation function using Smith's method.
+float gaSchlickGGX(float cosLi, float NdotV, float roughness)
+{
+	float r = roughness + 1.0;
+	float k = (r * r) / 8.0; // Epic suggests using this roughness remapping for analytic lights.
+	return gaSchlickG1(cosLi, k) * gaSchlickG1(NdotV, k);
+}
+
+float GeometrySchlickGGX(float NdotV, float roughness)
+{
+    float r = (roughness + 1.0);
+    float k = (r*r) / 8.0;
+
+    float nom   = NdotV;
+    float denom = NdotV * (1.0 - k) + k;
+
+    return nom / denom;
+}
+
+float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness)
+{
+    float NdotV = max(dot(N, V), 0.0);
+    float NdotL = max(dot(N, L), 0.0);
+    float ggx2 = GeometrySchlickGGX(NdotV, roughness);
+    float ggx1 = GeometrySchlickGGX(NdotL, roughness);
+
+    return ggx1 * ggx2;
+}
+
+// Shlick's approximation of the Fresnel factor.
+vec3 fresnelSchlick(vec3 F0, float cosTheta)
+{
+	return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
+}
+
+vec3 fresnelSchlickRoughness(vec3 F0, float cosTheta, float roughness)
+{
+    return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0);
+} 
+
+// ---------------------------------------------------------------------------------------------------
+// The following code (from Unreal Engine 4's paper) shows how to filter the environment map
+// for different roughnesses. This is mean to be computed offline and stored in cube map mips,
+// so turning this on online will cause poor performance
+float RadicalInverse_VdC(uint bits) 
+{
+    bits = (bits << 16u) | (bits >> 16u);
+    bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
+    bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
+    bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
+    bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
+    return float(bits) * 2.3283064365386963e-10; // / 0x100000000
+}
+
+vec2 Hammersley(uint i, uint N)
+{
+    return vec2(float(i)/float(N), RadicalInverse_VdC(i));
+}
+
+vec3 ImportanceSampleGGX(vec2 Xi, float Roughness, vec3 N)
+{
+	float a = Roughness * Roughness;
+	float Phi = 2 * PI * Xi.x;
+	float CosTheta = sqrt( (1 - Xi.y) / ( 1 + (a*a - 1) * Xi.y ) );
+	float SinTheta = sqrt( 1 - CosTheta * CosTheta );
+	vec3 H;
+	H.x = SinTheta * cos( Phi );
+	H.y = SinTheta * sin( Phi );
+	H.z = CosTheta;
+	vec3 UpVector = abs(N.z) < 0.999 ? vec3(0,0,1) : vec3(1,0,0);
+	vec3 TangentX = normalize( cross( UpVector, N ) );
+	vec3 TangentY = cross( N, TangentX );
+	// Tangent to world space
+	return TangentX * H.x + TangentY * H.y + N * H.z;
+}
+
+float TotalWeight = 0.0;
+
+vec3 PrefilterEnvMap(float Roughness, vec3 R)
+{
+	vec3 N = R;
+	vec3 V = R;
+	vec3 PrefilteredColor = vec3(0.0);
+	int NumSamples = 1024;
+	for(int i = 0; i < NumSamples; i++)
+	{
+		vec2 Xi = Hammersley(i, NumSamples);
+		vec3 H = ImportanceSampleGGX(Xi, Roughness, N);
+		vec3 L = 2 * dot(V, H) * H - V;
+		float NoL = clamp(dot(N, L), 0.0, 1.0);
+		if (NoL > 0)
+		{
+			PrefilteredColor += texture(u_EnvRadianceTex, L).rgb * NoL;
+			TotalWeight += NoL;
+		}
+	}
+	return PrefilteredColor / TotalWeight;
+}
+
+// ---------------------------------------------------------------------------------------------------
+
+vec3 RotateVectorAboutY(float angle, vec3 vec)
+{
+    angle = radians(angle);
+    mat3x3 rotationMatrix ={vec3(cos(angle),0.0,sin(angle)),
+                            vec3(0.0,1.0,0.0),
+                            vec3(-sin(angle),0.0,cos(angle))};
+    return rotationMatrix * vec;
+}
+
+vec3 Lighting(vec3 F0)
+{
+	vec3 result = vec3(0.0);
+	for(int i = 0; i < LightCount; i++)
+	{
+		vec3 Li = -lights.Direction;
+		vec3 Lradiance = lights.Radiance;
+		vec3 Lh = normalize(Li + m_Params.View);
+
+		// Calculate angles between surface normal and various light vectors.
+		float cosLi = max(0.0, dot(m_Params.Normal, Li));
+		float cosLh = max(0.0, dot(m_Params.Normal, Lh));
+
+		vec3 F = fresnelSchlick(F0, max(0.0, dot(Lh, m_Params.View)));
+		float D = ndfGGX(cosLh, m_Params.Roughness);
+		float G = gaSchlickGGX(cosLi, m_Params.NdotV, m_Params.Roughness);
+
+		vec3 kd = (1.0 - F) * (1.0 - m_Params.Metalness);
+		vec3 diffuseBRDF = kd * m_Params.Albedo;
+
+		// Cook-Torrance
+		vec3 specularBRDF = (F * D * G) / max(Epsilon, 4.0 * cosLi * m_Params.NdotV);
+
+		result += (diffuseBRDF + specularBRDF) * Lradiance * cosLi;
+	}
+	return result;
+}
+
+vec3 IBL(vec3 F0, vec3 Lr)
+{
+	vec3 irradiance = texture(u_EnvIrradianceTex, m_Params.Normal).rgb;
+	vec3 F = fresnelSchlickRoughness(F0, m_Params.NdotV, m_Params.Roughness);
+	vec3 kd = (1.0 - F) * (1.0 - m_Params.Metalness);
+	vec3 diffuseIBL = m_Params.Albedo * irradiance;
+
+	int u_EnvRadianceTexLevels = textureQueryLevels(u_EnvRadianceTex);
+	float NoV = clamp(m_Params.NdotV, 0.0, 1.0);
+	vec3 R = 2.0 * dot(m_Params.View, m_Params.Normal) * m_Params.Normal - m_Params.View;
+	vec3 specularIrradiance = textureLod(u_EnvRadianceTex, RotateVectorAboutY(u_EnvMapRotation, Lr), (m_Params.Roughness * m_Params.Roughness) * u_EnvRadianceTexLevels).rgb;
+
+	// Sample BRDF Lut, 1.0 - roughness for y-coord because texture was generated (in Sparky) for gloss model
+	vec2 specularBRDF = texture(u_BRDFLUTTexture, vec2(m_Params.NdotV, 1.0 - m_Params.Roughness)).rg;
+	vec3 specularIBL = specularIrradiance * (F * specularBRDF.x + specularBRDF.y);
+
+	return kd * diffuseIBL + specularIBL;
+}
+
+void main()
+{
+	// Standard PBR inputs
+	m_Params.Albedo = u_AlbedoTexToggle > 0.5 ? texture(u_AlbedoTexture, vs_Input.TexCoord).rgb : u_AlbedoColor; 
+	m_Params.Metalness = u_MetalnessTexToggle > 0.5 ? texture(u_MetalnessTexture, vs_Input.TexCoord).r : u_Metalness;
+	m_Params.Roughness = u_RoughnessTexToggle > 0.5 ?  texture(u_RoughnessTexture, vs_Input.TexCoord).r : u_Roughness;
+    m_Params.Roughness = max(m_Params.Roughness, 0.05); // Minimum roughness of 0.05 to keep specular highlight
+
+	// Normals (either from vertex or map)
+	m_Params.Normal = normalize(vs_Input.Normal);
+	if (u_NormalTexToggle > 0.5)
+	{
+		m_Params.Normal = normalize(2.0 * texture(u_NormalTexture, vs_Input.TexCoord).rgb - 1.0);
+		m_Params.Normal = normalize(vs_Input.WorldNormals * m_Params.Normal);
+	}
+
+	m_Params.View = normalize(u_CameraPosition - vs_Input.WorldPosition);
+	m_Params.NdotV = max(dot(m_Params.Normal, m_Params.View), 0.0);
+		
+	// Specular reflection vector
+	vec3 Lr = 2.0 * m_Params.NdotV * m_Params.Normal - m_Params.View;
+
+	// Fresnel reflectance, metals use albedo
+	vec3 F0 = mix(Fdielectric, m_Params.Albedo, m_Params.Metalness);
+
+	vec3 lightContribution = Lighting(F0);
+	vec3 iblContribution = IBL(F0, Lr);
+
+	color = vec4(lightContribution + iblContribution, 1.0);
+}

Editor/assets/shaders/Skybox.glsl

@@ -0,0 +1,33 @@
+// Skybox shader
+
+#type vertex
+#version 430
+
+layout(location = 0) in vec3 a_Position;
+
+uniform mat4 u_InverseVP;
+
+out vec3 v_Position;
+
+void main()
+{
+	vec4 position = vec4(a_Position.xy, 1.0, 1.0);
+	gl_Position = position;
+
+	v_Position = (u_InverseVP * position).xyz;
+}
+
+#type fragment
+#version 430
+
+layout(location = 0) out vec4 finalColor;
+
+uniform samplerCube u_Texture;
+uniform float u_TextureLod;
+
+in vec3 v_Position;
+
+void main()
+{
+	finalColor = textureLod(u_Texture, v_Position, u_TextureLod);
+}

Editor/assets/shaders/hdr.glsl

@@ -8,7 +8,7 @@ out vec2 v_TexCoord;
 
 void main()
 {
-	vec4 position = vec4(a_Position.xy, 1.0, 1.0);
+	vec4 position = vec4(a_Position.xy, 0.0, 1.0);
 	v_TexCoord = a_TexCoord;
 	gl_Position = position;
 }

Editor/assets/shaders/shader.glsl

@@ -22,11 +22,14 @@ void main()
 
 layout(location = 0) out vec4 finalColor;
 
-//uniform vec4 u_Color;
+uniform vec4 u_Color;
 
 in vec3 v_Normal;
 
 void main()
 {
+	finalColor = vec4(0.8, 0.0, 0.8, 1.0);
+
+
 	finalColor = vec4((v_Normal * 0.5 + 0.5), 1.0);// * u_Color.xyz, 1.0);
 }

Editor/assets/shaders/simplepbr_Static.glsl

@@ -1,321 +0,0 @@
-// -----------------------------
-// -- Hazel Engine PBR shader --
-// -----------------------------
-// Note: this shader is still very much in progress. There are likely many bugs and future additions that will go in.
-//       Currently heavily updated.
-//
-// References upon which this is based:
-// - Unreal Engine 4 PBR notes (https://blog.selfshadow.com/publications/s2013-shading-course/karis/s2013_pbs_epic_notes_v2.pdf)
-// - Frostbite's SIGGRAPH 2014 paper (https://seblagarde.wordpress.com/2015/07/14/siggraph-2014-moving-frostbite-to-physically-based-rendering/)
-// - Michał Siejak's PBR project (https://github.com/Nadrin)
-// - My implementation from years ago in the Sparky engine (https://github.com/TheCherno/Sparky)
-#type vertex
-#version 430 core
-
-layout(location = 0) in vec3 a_Position;
-layout(location = 1) in vec3 a_Normal;
-layout(location = 2) in vec3 a_Tangent;
-layout(location = 3) in vec3 a_Binormal;
-layout(location = 4) in vec2 a_TexCoord;
-
-uniform mat4 u_ViewProjectionMatrix;
-uniform mat4 u_ModelMatrix;
-
-out VertexOutput
-{
-    vec3 WorldPosition;
-    vec3 Normal;
-    vec2 TexCoord;
-    mat3 WorldNormals;
-    vec3 Binormal;
-} vs_Output;
-
-void main()
-{
-    vs_Output.WorldPosition = vec3(u_ModelMatrix * vec4(a_Position, 1.0));
-    vs_Output.Normal = a_Normal;
-    vs_Output.TexCoord = vec2(a_TexCoord.x, 1.0 - a_TexCoord.y);
-    vs_Output.WorldNormals = mat3(u_ModelMatrix) * mat3(a_Tangent, a_Binormal, a_Normal);
-    vs_Output.Binormal = a_Binormal;
-
-    gl_Position = u_ViewProjectionMatrix * u_ModelMatrix * vec4(a_Position, 1.0);
-}
-
-#type fragment
-#version 430 core
-
-const float PI = 3.141592;
-const float Epsilon = 0.00001;
-
-const int LightCount = 1;
-
-// Constant normal incidence Fresnel factor for all dielectrics.
-const vec3 Fdielectric = vec3(0.04);
-
-struct Light {
-    vec3 Direction;
-    vec3 Radiance;
-};
-
-in VertexOutput
-{
-    vec3 WorldPosition;
-    vec3 Normal;
-    vec2 TexCoord;
-    mat3 WorldNormals;
-    vec3 Binormal;
-} vs_Input;
-
-layout(location = 0) out vec4 color;
-
-uniform Light lights;
-uniform vec3 u_CameraPosition;
-
-// PBR texture inputs
-uniform sampler2D u_AlbedoTexture;
-uniform sampler2D u_NormalTexture;
-uniform sampler2D u_MetalnessTexture;
-uniform sampler2D u_RoughnessTexture;
-
-// Environment maps
-uniform samplerCube u_EnvRadianceTex;
-uniform samplerCube u_EnvIrradianceTex;
-
-// BRDF LUT
-uniform sampler2D u_BRDFLUTTexture;
-
-uniform vec3 u_AlbedoColor;
-uniform float u_Metalness;
-uniform float u_Roughness;
-
-uniform float u_EnvMapRotation;
-
-// Toggles
-uniform float u_RadiancePrefilter;
-uniform float u_AlbedoTexToggle;
-uniform float u_NormalTexToggle;
-uniform float u_MetalnessTexToggle;
-uniform float u_RoughnessTexToggle;
-
-struct PBRParameters
-{
-    vec3 Albedo;
-    float Roughness;
-    float Metalness;
-
-    vec3 Normal;
-    vec3 View;
-    float NdotV;
-};
-
-PBRParameters m_Params;
-
-// GGX/Towbridge-Reitz normal distribution function.
-// Uses Disney's reparametrization of alpha = roughness^2
-float ndfGGX(float cosLh, float roughness)
-{
-    float alpha = roughness * roughness;
-    float alphaSq = alpha * alpha;
-
-    float denom = (cosLh * cosLh) * (alphaSq - 1.0) + 1.0;
-    return alphaSq / (PI * denom * denom);
-}
-
-// Single term for separable Schlick-GGX below.
-float gaSchlickG1(float cosTheta, float k)
-{
-    return cosTheta / (cosTheta * (1.0 - k) + k);
-}
-
-// Schlick-GGX approximation of geometric attenuation function using Smith's method.
-float gaSchlickGGX(float cosLi, float NdotV, float roughness)
-{
-    float r = roughness + 1.0;
-    float k = (r * r) / 8.0; // Epic suggests using this roughness remapping for analytic lights.
-    return gaSchlickG1(cosLi, k) * gaSchlickG1(NdotV, k);
-}
-
-float GeometrySchlickGGX(float NdotV, float roughness)
-{
-    float r = (roughness + 1.0);
-    float k = (r*r) / 8.0;
-
-    float nom   = NdotV;
-    float denom = NdotV * (1.0 - k) + k;
-
-    return nom / denom;
-}
-
-float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness)
-{
-    float NdotV = max(dot(N, V), 0.0);
-    float NdotL = max(dot(N, L), 0.0);
-    float ggx2 = GeometrySchlickGGX(NdotV, roughness);
-    float ggx1 = GeometrySchlickGGX(NdotL, roughness);
-
-    return ggx1 * ggx2;
-}
-
-// Shlick's approximation of the Fresnel factor.
-vec3 fresnelSchlick(vec3 F0, float cosTheta)
-{
-    return F0 + (1.0 - F0) * pow(1.0 - cosTheta, 5.0);
-}
-
-vec3 fresnelSchlickRoughness(vec3 F0, float cosTheta, float roughness)
-{
-    return F0 + (max(vec3(1.0 - roughness), F0) - F0) * pow(1.0 - cosTheta, 5.0);
-}
-
-// ---------------------------------------------------------------------------------------------------
-// The following code (from Unreal Engine 4's paper) shows how to filter the environment map
-// for different roughnesses. This is mean to be computed offline and stored in cube map mips,
-// so turning this on online will cause poor performance
-float RadicalInverse_VdC(uint bits)
-{
-    bits = (bits << 16u) | (bits >> 16u);
-    bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);
-    bits = ((bits & 0x33333333u) << 2u) | ((bits & 0xCCCCCCCCu) >> 2u);
-    bits = ((bits & 0x0F0F0F0Fu) << 4u) | ((bits & 0xF0F0F0F0u) >> 4u);
-    bits = ((bits & 0x00FF00FFu) << 8u) | ((bits & 0xFF00FF00u) >> 8u);
-    return float(bits) * 2.3283064365386963e-10; // / 0x100000000
-}
-
-vec2 Hammersley(uint i, uint N)
-{
-    return vec2(float(i)/float(N), RadicalInverse_VdC(i));
-}
-
-vec3 ImportanceSampleGGX(vec2 Xi, float Roughness, vec3 N)
-{
-    float a = Roughness * Roughness;
-    float Phi = 2 * PI * Xi.x;
-    float CosTheta = sqrt( (1 - Xi.y) / ( 1 + (a*a - 1) * Xi.y ) );
-    float SinTheta = sqrt( 1 - CosTheta * CosTheta );
-    vec3 H;
-    H.x = SinTheta * cos( Phi );
-    H.y = SinTheta * sin( Phi );
-    H.z = CosTheta;
-    vec3 UpVector = abs(N.z) < 0.999 ? vec3(0,0,1) : vec3(1,0,0);
-    vec3 TangentX = normalize( cross( UpVector, N ) );
-    vec3 TangentY = cross( N, TangentX );
-    // Tangent to world space
-    return TangentX * H.x + TangentY * H.y + N * H.z;
-}
-
-float TotalWeight = 0.0;
-
-vec3 PrefilterEnvMap(float Roughness, vec3 R)
-{
-    vec3 N = R;
-    vec3 V = R;
-    vec3 PrefilteredColor = vec3(0.0);
-    int NumSamples = 1024;
-    for(int i = 0; i < NumSamples; i++)
-    {
-        vec2 Xi = Hammersley(i, NumSamples);
-        vec3 H = ImportanceSampleGGX(Xi, Roughness, N);
-        vec3 L = 2 * dot(V, H) * H - V;
-        float NoL = clamp(dot(N, L), 0.0, 1.0);
-        if (NoL > 0)
-        {
-            PrefilteredColor += texture(u_EnvRadianceTex, L).rgb * NoL;
-            TotalWeight += NoL;
-        }
-    }
-    return PrefilteredColor / TotalWeight;
-}
-
-// ---------------------------------------------------------------------------------------------------
-
-vec3 RotateVectorAboutY(float angle, vec3 vec)
-{
-    angle = radians(angle);
-    mat3x3 rotationMatrix ={vec3(cos(angle),0.0,sin(angle)),
-    vec3(0.0,1.0,0.0),
-    vec3(-sin(angle),0.0,cos(angle))};
-    return rotationMatrix * vec;
-}
-
-vec3 Lighting(vec3 F0)
-{
-    vec3 result = vec3(0.0);
-    for(int i = 0; i < LightCount; i++)
-    {
-        vec3 Li = -lights.Direction;
-        vec3 Lradiance = lights.Radiance;
-        vec3 Lh = normalize(Li + m_Params.View);
-
-        // Calculate angles between surface normal and various light vectors.
-        float cosLi = max(0.0, dot(m_Params.Normal, Li));
-        float cosLh = max(0.0, dot(m_Params.Normal, Lh));
-
-        vec3 F = fresnelSchlick(F0, max(0.0, dot(Lh, m_Params.View)));
-        float D = ndfGGX(cosLh, m_Params.Roughness);
-        float G = gaSchlickGGX(cosLi, m_Params.NdotV, m_Params.Roughness);
-
-        vec3 kd = (1.0 - F) * (1.0 - m_Params.Metalness);
-        vec3 diffuseBRDF = kd * m_Params.Albedo;
-
-        // Cook-Torrance
-        vec3 specularBRDF = (F * D * G) / max(Epsilon, 4.0 * cosLi * m_Params.NdotV);
-
-        result += (diffuseBRDF + specularBRDF) * Lradiance * cosLi;
-    }
-    return result;
-}
-
-vec3 IBL(vec3 F0, vec3 Lr)
-{
-    vec3 irradiance = texture(u_EnvIrradianceTex, m_Params.Normal).rgb;
-    vec3 F = fresnelSchlickRoughness(F0, m_Params.NdotV, m_Params.Roughness);
-    vec3 kd = (1.0 - F) * (1.0 - m_Params.Metalness);
-    vec3 diffuseIBL = m_Params.Albedo * irradiance;
-
-    int u_EnvRadianceTexLevels = textureQueryLevels(u_EnvRadianceTex);
-    float NoV = clamp(m_Params.NdotV, 0.0, 1.0);
-    vec3 R = 2.0 * dot(m_Params.View, m_Params.Normal) * m_Params.Normal - m_Params.View;
-    vec3 specularIrradiance = vec3(0.0);
-
-    if (u_RadiancePrefilter > 0.5)
-    specularIrradiance = PrefilterEnvMap(m_Params.Roughness * m_Params.Roughness, R) * u_RadiancePrefilter;
-    else
-    specularIrradiance = textureLod(u_EnvRadianceTex, RotateVectorAboutY(u_EnvMapRotation, Lr), sqrt(m_Params.Roughness) * u_EnvRadianceTexLevels).rgb * (1.0 - u_RadiancePrefilter);
-
-    // Sample BRDF Lut, 1.0 - roughness for y-coord because texture was generated (in Sparky) for gloss model
-    vec2 specularBRDF = texture(u_BRDFLUTTexture, vec2(m_Params.NdotV, 1.0 - m_Params.Roughness)).rg;
-    vec3 specularIBL = specularIrradiance * (F * specularBRDF.x + specularBRDF.y);
-
-    return kd * diffuseIBL + specularIBL;
-}
-
-void main()
-{
-    // Standard PBR inputs
-    m_Params.Albedo = u_AlbedoTexToggle > 0.5 ? texture(u_AlbedoTexture, vs_Input.TexCoord).rgb : u_AlbedoColor;
-    m_Params.Metalness = u_MetalnessTexToggle > 0.5 ? texture(u_MetalnessTexture, vs_Input.TexCoord).r : u_Metalness;
-    m_Params.Roughness = u_RoughnessTexToggle > 0.5 ?  texture(u_RoughnessTexture, vs_Input.TexCoord).r : u_Roughness;
-    m_Params.Roughness = max(m_Params.Roughness, 0.05); // Minimum roughness of 0.05 to keep specular highlight
-
-    // Normals (either from vertex or map)
-    m_Params.Normal = normalize(vs_Input.Normal);
-    if (u_NormalTexToggle > 0.5)
-    {
-        m_Params.Normal = normalize(2.0 * texture(u_NormalTexture, vs_Input.TexCoord).rgb - 1.0);
-        m_Params.Normal = normalize(vs_Input.WorldNormals * m_Params.Normal);
-    }
-
-    m_Params.View = normalize(u_CameraPosition - vs_Input.WorldPosition);
-    m_Params.NdotV = max(dot(m_Params.Normal, m_Params.View), 0.0);
-
-    // Specular reflection vector
-    vec3 Lr = 2.0 * m_Params.NdotV * m_Params.Normal - m_Params.View;
-
-    // Fresnel reflectance, metals use albedo
-    vec3 F0 = mix(Fdielectric, m_Params.Albedo, m_Params.Metalness);
-
-    vec3 lightContribution = Lighting(F0);
-    vec3 iblContribution = IBL(F0, Lr);
-
-    color = vec4(lightContribution + iblContribution, 1.0);
-}