matrix-engine-wgpu 1.3.19 → 1.4.1

package/src/shaders/fragment.wgsl.js

@@ -1,75 +1,137 @@
 export let fragmentWGSL = `override shadowDepthTextureSize: f32 = 1024.0;
 
+// Created by Nikola Lukic with chatgtp assist.
+
 struct Scene {
-  lightViewProjMatrix : mat4x4f,
-  cameraViewProjMatrix : mat4x4f,
-  lightPos : vec3f,
-  padding : f32, // Required for alignment
-}
+    lightViewProjMatrix  : mat4x4f,
+    cameraViewProjMatrix : mat4x4f,
+    cameraPos            : vec3f,
+    padding2             : f32,   // align to 16 bytes
+    lightPos             : vec3f,
+    padding              : f32,   // align to 16 bytes
+};
 
 struct SpotLight {
-  position: vec3f,
-  _pad1: f32,
-  direction: vec3f,
-  _pad2: f32,
-  innerCutoff: f32,
-  outerCutoff: f32,
-  _pad3: vec2f,
-}
+    position      : vec3f,
+    _pad1         : f32,
+
+    direction     : vec3f,
+    _pad2         : f32,
+
+    innerCutoff   : f32,
+    outerCutoff   : f32,
+    intensity     : f32,
+    _pad3         : f32,
+
+    color         : vec3f,
+    _pad4         : f32,
+
+    range         : f32,
+    ambientFactor : f32,
+    shadowBias    : f32,
+    _pad5         : f32,
+
+    lightViewProj : mat4x4<f32>,
+};
+
+const MAX_SPOTLIGHTS = 20u;
 
 @group(0) @binding(0) var<uniform> scene : Scene;
-@group(0) @binding(1) var shadowMap: texture_depth_2d;
+@group(0) @binding(1) var shadowMapArray: texture_depth_2d_array;
 @group(0) @binding(2) var shadowSampler: sampler_comparison;
 @group(0) @binding(3) var meshTexture: texture_2d<f32>;
 @group(0) @binding(4) var meshSampler: sampler;
-@group(0) @binding(5) var<uniform> spotlight: SpotLight;
+@group(0) @binding(5) var<uniform> spotlights: array<SpotLight, MAX_SPOTLIGHTS>;
 
 struct FragmentInput {
-  @location(0) shadowPos : vec3f,
-  @location(1) fragPos : vec3f,
-  @location(2) fragNorm : vec3f,
-  @location(3) uv : vec2f,
+    @location(0) shadowPos : vec4f,
+    @location(1) fragPos   : vec3f,
+    @location(2) fragNorm  : vec3f,
+    @location(3) uv        : vec2f,
 }
 
 const albedo = vec3f(0.9);
-const ambientFactor = 0.7;
 
 fn calculateSpotlightFactor(light: SpotLight, fragPos: vec3f) -> f32 {
-  let L = normalize(light.position - fragPos);
-  let theta = dot(L, normalize(-light.direction));
-  let epsilon = light.innerCutoff - light.outerCutoff;
-  let intensity = clamp((theta - light.outerCutoff) / epsilon, 0.0, 1.0);
-  return intensity;
+    let L = normalize(light.position - fragPos);
+    let theta = dot(L, normalize(-light.direction));
+    let epsilon = light.innerCutoff - light.outerCutoff;
+    return clamp((theta - light.outerCutoff) / epsilon, 0.0, 1.0);
 }
 
-@fragment
-fn main(input : FragmentInput) -> @location(0) vec4f {
-  // Shadow PFC
-  var visibility = 0.0;
-  let oneOverSize = 1.0 / shadowDepthTextureSize;
-  for (var y = -1; y <= 1; y++) {
-    for (var x = -1; x <= 1; x++) {
-      let offset = vec2f(vec2(x, y)) * oneOverSize;
-      visibility += textureSampleCompare(
-        shadowMap, shadowSampler,
-        input.shadowPos.xy + offset, input.shadowPos.z - 0.007
-      );
-    }
-  }
-  visibility /= 9.0;
+fn computeSpotLight(light: SpotLight, normal: vec3f, fragPos: vec3f, viewDir: vec3f) -> vec3f {
+    let L = light.position - fragPos;
+    let distance = length(L);
+    let lightDir = normalize(L);
+
+    let spotFactor = calculateSpotlightFactor(light, fragPos);
+    let atten = clamp(1.0 - (distance / light.range), 0.0, 1.0);
 
-  // Lambert
-  let norm = normalize(input.fragNorm);
-  let lightDir = normalize(scene.lightPos - input.fragPos);
-  let lambert = max(dot(norm, lightDir), 0.0);
+    let diff = max(dot(normal, lightDir), 0.0);
+    let halfwayDir = normalize(lightDir + viewDir);
+    let spec = pow(max(dot(normal, halfwayDir), 0.0), 32.0);
 
-  // Spotlight effect
-  let spotlightFactor = calculateSpotlightFactor(spotlight, input.fragPos);
+    let diffuse  = diff * light.color * light.intensity * atten;
+    let specular = spec * light.color * light.intensity * atten;
 
-  // Combine
-  let lightIntensity = ambientFactor + lambert * visibility * spotlightFactor;
-  let texColor = textureSample(meshTexture, meshSampler, input.uv);
+    return (diffuse + specular) * spotFactor;
+}
+
+// Corrected PCF for texture_depth_2d_array
+fn sampleShadow(shadowUV: vec2f, layer: i32, depthRef: f32, normal: vec3f, lightDir: vec3f) -> f32 {
+    var visibility: f32 = 0.0;
+    let biasConstant: f32 = 0.001;
+    // Slope bias: avoid self-shadowing on steep angles
+    // let slopeBias: f32 = max(0.002 * (1.0 - dot(normal, lightDir)), 0.0);
+    let bias = biasConstant;//  + slopeBias;
+
+    let oneOverSize = 1.0 / (shadowDepthTextureSize  * 0.5);
 
-  return vec4f(texColor.rgb * lightIntensity * albedo, 1.0);
+    // 3x3 PCF kernel
+    let offsets: array<vec2f, 9> = array<vec2f, 9>(
+        vec2(-1.0, -1.0), vec2(0.0, -1.0), vec2(1.0, -1.0),
+        vec2(-1.0,  0.0), vec2(0.0,  0.0), vec2(1.0,  0.0),
+        vec2(-1.0,  1.0), vec2(0.0,  1.0), vec2(1.0,  1.0)
+    );
+
+    for(var i: u32 = 0u; i < 9u; i = i + 1u) {
+        visibility += textureSampleCompare(
+            shadowMapArray,
+            shadowSampler,
+            shadowUV + offsets[i] * oneOverSize,
+            layer,
+            depthRef //+ bias
+        );
+    }
+    return visibility / 9.0;
 }
-`
+
+@fragment
+fn main(input: FragmentInput) -> @location(0) vec4f {
+    let norm = normalize(input.fragNorm);
+
+    let viewDir = normalize(scene.cameraPos - input.fragPos);
+    // let viewDir = normalize(scene.cameraViewProjMatrix[3].xyz - input.fragPos);
+
+    var lightContribution = vec3f(0.0);
+    var ambient = vec3f(0.0);
+
+    for (var i: u32 = 0u; i < MAX_SPOTLIGHTS; i = i + 1u) {
+        let sc = spotlights[i].lightViewProj * vec4<f32>(input.fragPos, 1.0);
+        let p  = sc.xyz / sc.w;
+        let uv = clamp(p.xy * 0.5 + vec2<f32>(0.5), vec2<f32>(0.0), vec2<f32>(1.0));
+        let depthRef = p.z * 0.5 + 0.5;
+        let lightDir = normalize(spotlights[i].position - input.fragPos);
+        let angleFactor = 1.0 - dot(norm, lightDir);
+        let slopeBias = 0.01 * (1.0 - dot(norm, lightDir));
+        let bias = spotlights[i].shadowBias + slopeBias;
+        let visibility = sampleShadow(uv, i32(i), depthRef - bias, norm, lightDir);
+        let contrib = computeSpotLight(spotlights[i], norm, input.fragPos, viewDir);
+        lightContribution += contrib * visibility;
+        ambient += spotlights[i].ambientFactor * spotlights[i].color;
+    }
+
+    let texColor = textureSample(meshTexture, meshSampler, input.uv);
+    let finalColor = texColor.rgb * (ambient + lightContribution); // * albedo;
+    return vec4f(finalColor, 1.0);
+}`;

package/src/shaders/shaders.js

@@ -48,4 +48,3 @@ fn fragmentMain(input: VertexOutput) -> @location(0) vec4f {
 
   return vec4f(textureColor.rgb * lightColor, textureColor.a);
 }`;
-

package/src/shaders/vertex.wgsl.js

@@ -12,11 +12,10 @@ struct Model {
 @group(1) @binding(0) var<uniform> model : Model;
 
 struct VertexOutput {
-  @location(0) shadowPos: vec3f,
+  @location(0) shadowPos: vec4f,  // now vec4
   @location(1) fragPos: vec3f,
   @location(2) fragNorm: vec3f,
-  @location(3) uv : vec2f,
-
+  @location(3) uv: vec2f,
   @builtin(position) Position: vec4f,
 }
 
@@ -24,31 +23,18 @@ struct VertexOutput {
 fn main(
   @location(0) position: vec3f,
   @location(1) normal: vec3f,
-  @location(2) uv : vec2f
+  @location(2) uv: vec2f
 ) -> VertexOutput {
   var output : VertexOutput;
 
-  // XY is in (-1, 1) space, Z is in (0, 1) space
   let posFromLight = scene.lightViewProjMatrix * model.modelMatrix * vec4(position, 1.0);
-
-  // Convert XY to (0, 1)
-  // Y is flipped because texture coords are Y-down.
-  output.shadowPos = vec3(
-    posFromLight.xy * vec2(0.5, -0.5) + vec2(0.5),
-    posFromLight.z
-  );
-
-  // follewed camera code
-  // output.Position = scene.cameraViewProjMatrix * model.modelMatrix * vec4(position, 1.0);
-  // output.fragPos = output.Position.xyz;
-  // output.fragNorm = normal;
+  output.shadowPos = posFromLight; // pass full vec4 for perspective divide
 
   let worldPos = model.modelMatrix * vec4(position, 1.0);
   output.Position = scene.cameraViewProjMatrix * worldPos;
-  output.fragPos = worldPos.xyz;          // ✅ world space
+  output.fragPos = worldPos.xyz;
 
   output.fragNorm = normalize((model.modelMatrix * vec4(normal, 0.0)).xyz);
   output.uv = uv;
   return output;
-}
-`;
+}`;