[Rendering] WIP on Standard shader and lighting;

Author: LittleCodingFox

BuiltinResources/Hidden/Shaders/Default/Standard.shader

@@ -6,15 +6,7 @@ Variants VERTEX_COLORS, LIT, HALF_LAMBERT, PER_VERTEX_LIGHTING, NORMALMAP, CUTOU
 
 Begin Parameters
 
-varying vec2 v_texcoord0 : TEXCOORD0 = vec2(0.0, 0.0)
-varying vec3 v_worldPos : TEXCOORD1
-varying vec3 v_normal : NORMAL
-varying vec3 v_lightNormal : TEXCOORD3
-varying vec4 v_color : COLOR
-varying float v_instanceID : TEXCOORD2
-varying vec3 v_tangent : TANGENT
-varying vec3 v_bitangent : BITANGENT
-
+uniform vec3 viewPosition;
 uniform texture ambientOcclusionTexture
 uniform color diffuseColor = #FFFFFFFF
 uniform texture diffuseTexture = WHITE
@@ -33,93 +25,130 @@ End Parameters
 Begin Instancing
 End Instancing
 
-Begin Vertex
+Begin Common
 
-$input a_position, a_texcoord0, a_normal, a_color0, a_tangent, a_bitangent
-$output v_texcoord0, v_worldPos, v_normal, v_color, v_instanceID, v_tangent, v_bitangent, v_lightNormal
+cbuffer Uniforms
+{
+	float3 viewPosition;
+	Sampler2D ambientOcclusionTexture;
+	float4 diffuseColor;
+	Sampler2D diffuseTexture;
+	Sampler2D displacementTexture;
+	float4 emissiveColor;
+	Sampler2D emissiveTexture;
+	Sampler2D heightTexture;
+	Sampler2D normalTexture;
+	float4 specularColor;
+	Sampler2D specularTexture;
+	float cutout;
+	float alphaThreshold;
+};
+
+struct VertexOutput
+{
+	float3 position : SV_Position;
+	float3 worldPosition;
+	float3 lightNormal;
+	float2 coords;
+	float3 normal;
+	float3 tangent;
+	float3 bitangent;
+	float4 color;
+	uint instanceID;
+};
+
+End Common
 
-#include "StapleLighting.sh"
+Begin Vertex
 
-void main()
+//TODO: Get slang to handle multiple preprocessor conditions
+
+struct Input
+{
+	float3 position : POSITION;
+	float2 coords : TEXCOORD0;
+	float3 normal : NORMAL;
+	float3 tangent : TANGENT;
+	float3 bitangent : BITANGENT;
+	float4 color : COLOR0;
+	uint instanceID : SV_InstanceID;
+};
+
+[shader("vertex")]
+VertexOutput VertexMain(Input input)
 {
-	mat4 model = StapleModelMatrix;
+	VertexOutput output;
 
-	#ifdef SKINNING
-	model = StapleGetSkinningMatrix(model, a_indices, a_weight);
-	#endif
+	float4x4 model = world;
 
-	mat4 projViewWorld = mul(mul(u_proj, u_view), model);
-	mat4 viewWorld = mul(u_view, model);
+	float4x4 projectionViewWorld = mul(mul(projection, view), model);
+	float4x4 viewWorld = mul(view, model);
 
-	vec4 v_pos = mul(projViewWorld, vec4(a_position, 1.0));
+	float4 vertexPosition = mul(projectionViewWorld, float4(input.position, 1.0));
 
-	gl_Position = v_pos;
+	output.position = vertexPosition.xyz;
 
-	v_worldPos = mul(model, vec4(a_position, 1.0)).xyz;
+	output.worldPosition = mul(model, float4(input.position, 1.0)).xyz;
 
-	v_texcoord0 = a_texcoord0;
-	v_normal = a_normal;
-	
-	v_lightNormal = StapleLightNormal(a_normal, model);
-	
-	v_tangent = a_tangent;
-	v_bitangent = a_bitangent;
+	output.coords = input.coords;
+	output.normal = input.normal;
+	output.tangent = input.tangent;
+	output.bitangent = input.bitangent;
+	output.lightNormal = StapleLightNormal(input.normal, model);
+	output.instanceID = input.instanceID;
 
-	v_instanceID = StapleInstanceID;
+//#if LIT && PER_VERTEX_LIGHTING
+	//output.color = float4x4(diffuseColor.rgb * StapleProcessLights(viewPosition, output.worldPosition, input.normal), diffuseColor.a);
 
-#if LIT && PER_VERTEX_LIGHTING
-	v_color = vec4(diffuseColor.rgb * StapleProcessLights(int(v_instanceID), u_viewPos, v_worldPos, v_normal), diffuseColor.a);
-	
-	#if VERTEX_COLORS
-		v_color = a_color0 * v_color;
-	#endif
-#else
-	v_color = a_color0;
-#endif
+	//#ifdef VERTEX_COLORS
+//		output.color = input.color * output.color;
+//	#endif
+//#else
+	output.color = input.color;
+//#endif
+
+	return output;
 }
 End Vertex
 
 Begin Fragment
 
-$input v_texcoord0, v_worldPos, v_normal, v_color, v_instanceID, v_tangent, v_bitangent, v_lightNormal
-
-#include "StapleLighting.sh"
-
-void main()
+[shader("fragment")]
+float4 FragmentMain(VertexOutput input) : SV_Target
 {
-#if VERTEX_COLORS || PER_VERTEX_LIGHTING
-	vec4 diffuse = v_color * diffuseColor;
-#else
-	vec4 diffuse = texture2D(diffuseTexture, v_texcoord0) * diffuseColor;
-#endif
+//#if VERTEX_COLORS || PER_VERTEX_LIGHTING
+//	float4 diffuse = input.color * diffuseColor;
+//#else
+	float4 diffuse = diffuseTexture.Sample(input.coords) * diffuseColor;
+//#endif
 
-#if CUTOUT
+#ifdef CUTOUT
 	if(diffuse.a < alphaThreshold)
 	{
 		discard;
-		
-		return;
 	}
 #endif
 
-#if LIT && PER_VERTEX_LIGHTING
-	gl_FragColor = diffuse;
+//#if LIT && PER_VERTEX_LIGHTING
+	return diffuse;
+/*
 #elif LIT
 
 #if NORMALMAP
-	mat3 tbn = mtxFromCols(normalize(v_tangent), normalize(v_bitangent), normalize(v_normal));
+	float3x3 tbn = float3x3(normalize(input.tangent), normalize(input.bitangent), normalize(input.normal));
 
-	vec3 normalMapNormal = normalize(texture2D(normalTexture, v_texcoord0).xyz * 2.0 - 1.0);
+	float3 normalMapNormal = normalize(normalTexture.Sample(v_texcoord0).xyz * 2.0 - 1.0);
 
-	vec3 light = StapleProcessLightsTangent(int(v_instanceID), u_viewPos, v_worldPos, normalMapNormal, tbn);
+	float3 light = StapleProcessLightsTangent(viewPosition, input.worldPosition, normalMapNormal, tbn);
 #else
-	vec3 light = StapleProcessLights(int(v_instanceID), u_viewPos, v_worldPos, v_lightNormal);
+	float3 light = StapleProcessLights(viewPosition, input.world, input.lightNormal);
 #endif
 
-	gl_FragColor = vec4(light, 1) * diffuse;
-#else
-	gl_FragColor = diffuse;
-#endif
+	return float4(light, 1) * diffuse;
+*/
+//#else
+	//return diffuse;
+//#endif
 }
 
 End Fragment

Tools/ShaderIncludes/Staple.slang

@@ -1,6 +1,7 @@
 module Staple;
 
 __include StapleMath;
+__include StapleLighting;
 
 #define STAPLE_SKINNING_STAGE_INDEX 15
 #define STAPLE_LIGHTING_NORMAL_MATRIX_STAGE_INDEX 14

Tools/ShaderIncludes/StapleLighting.slang

@@ -0,0 +1,96 @@
+implementing Staple;
+
+#define STAPLE_MAX_LIGHTS 16
+
+public struct LightSample
+{
+    float3 diffuse;
+    float3 direction;
+};
+
+public interface ILight
+{
+    LightSample Sample(float3 target);
+}
+
+public struct PointLight : ILight
+{
+    float3 position;
+    float3 diffuse;
+
+    LightSample Sample(float3 target)
+    {
+        float3 delta = target - position;
+        float distance = length(delta);
+
+        LightSample sample;
+
+        sample.direction = normalize(delta);
+        sample.diffuse = diffuse;
+
+        return sample;
+    }
+};
+
+public struct DirectionalLight : ILight
+{
+    float3 direction;
+    float3 diffuse;
+
+    LightSample Sample(float3 target)
+    {
+        LightSample sample;
+
+        sample.direction = normalize(direction);
+        sample.diffuse = diffuse;
+
+        return sample;
+    }
+};
+
+public float3 StapleLightNormal(float3 normal, float4x4 modelView)
+{
+    float4x4 inverseMatrix = transpose(inverse(modelView));
+
+    float3x3 normalMatrix = float3x3(inverseMatrix[0].xyz,
+        inverseMatrix[1].xyz,
+        inverseMatrix[2].xyz);
+
+    return normalize(mul(normalMatrix, normal));
+}
+
+public float StapleLightScaling(float nDotL)
+{
+#ifdef HALF_LAMBERT
+    return pow(nDotL * 0.5 + 0.5, 2);
+#else
+    return nDotL;
+#endif
+}
+
+public float4 StapleLightDiffuse<L: ILight>(float3 position, float3 normal, L light)
+{
+    LightSample sample = light.Sample(position);
+
+    float nDotL = max(0, StapleLightScaling(dot(normal, sample.direction)));
+
+    return float4(sample.diffuse * nDotL, 1);
+}
+
+public float4 StapleProcessLights<L: ILight>(float3 viewPosition, float3 worldPosition, float3 normal, float4 ambient,
+    float4 albedo, ILight[] lights)
+{
+    if(lights.getCount() == 0)
+    {
+        return ambient;
+    }
+
+    float4 diffuse;
+
+    for(int i = 0; i < lights.getCount(); i++)
+    {
+        diffuse += StapleLightDiffuse(worldPosition, normal, lights[i]);
+    }
+
+    return ambient + diffuse;
+}