@luma.gl/shaders 10.0.0-alpha.10 → 10.0.0-alpha.11

package/src/modules/lighting/pbr-material/pbr-material-wgsl.ts

@@ -1268,7 +1268,9 @@ fn calculateFinalColor(pbrInfo: PBRInfo, lightColor: vec3<f32>) -> vec3<f32> {
 }
 
 // Visibility for the first four spotlights; environment and other lights are unaffected.
-fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f) -> vec4<f32> {
+var<private> pbr_ambientVisibility: f32 = 1.0;
+
+fn pbr_filterColorWithShadows(vertexColor: vec4<f32>, directionalVisibility: f32, pointVisibility: vec4f, spotVisibility: vec4f) -> vec4<f32> {
   let baseColorUV = getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform);
   let metallicRoughnessUV = getMaterialUV(
     pbrMaterial.metallicRoughnessUVSet,
@@ -1361,7 +1363,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
     color = baseColor.rgb;
     #ifdef HAS_LIGHTMAP
     if (pbrMaterial.lightmapMapEnabled != 0u) {
-      color *= lightmapIrradiance / M_PI;
+      color *= lightmapIrradiance / M_PI * pbr_ambientVisibility;
       #ifdef HAS_OCCLUSIONMAP
       if (pbrMaterial.occlusionMapEnabled != 0) {
         let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSamplerSampler, occlusionUV).r;
@@ -1464,12 +1466,12 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
 
       #ifdef USE_LIGHTS
       PBRInfo_setAmbientLight(&pbrInfo);
-      color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+      color += calculateFinalColor(pbrInfo, lighting.ambientColor * pbr_ambientVisibility);
 
       for (var i = 0; i < lighting.directionalLightCount; i++) {
         if (i < lighting.directionalLightCount) {
           PBRInfo_setDirectionalLight(&pbrInfo, -lighting_getDirectionalLight(i).direction);
-          color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+          color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color * select(1.0, clamp(directionalVisibility, 0.0, 1.0), i == 0));
         }
       }
 
@@ -1480,7 +1482,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
             lighting_getPointLight(i),
             distance(lighting_getPointLight(i).position, fragmentInputs.pbr_vPosition)
           );
-          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color * select(1.0, clamp(pointVisibility[min(i, 3)], 0.0, 1.0), i < 4) / attenuation);
         }
       }
 
@@ -1509,7 +1511,8 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
       }
       #endif
 
-      #ifdef USE_IBL
+      let indirectBaseColor = color;
+#ifdef USE_IBL
       if (pbrMaterial.IBLenabled != 0) {
         color += getIBLContribution(pbrInfo, n, reflection);
       }
@@ -1517,6 +1520,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
 
       // The pinned KHR_lightmap draft explicitly defines c_diff = (1 - metallic) * baseColor.
       color += baseColor.rgb * (1.0 - metallic) * lightmapIrradiance / M_PI;
+      color = indirectBaseColor + (color - indirectBaseColor) * pbr_ambientVisibility;
 
       #ifdef HAS_OCCLUSIONMAP
       if (pbrMaterial.occlusionMapEnabled != 0) {
@@ -1815,7 +1819,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
     PBRInfo_setAmbientLight(&pbrInfo);
     color += calculateMaterialLightColor(
       pbrInfo,
-      lighting.ambientColor,
+      lighting.ambientColor * pbr_ambientVisibility,
       clearcoatNormal,
       clearcoatFactor,
       clearcoatRoughness,
@@ -1831,7 +1835,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
         PBRInfo_setDirectionalLight(&pbrInfo, -lighting_getDirectionalLight(i).direction);
         color += calculateMaterialLightColor(
           pbrInfo,
-          lighting_getDirectionalLight(i).color,
+          lighting_getDirectionalLight(i).color * select(1.0, clamp(directionalVisibility, 0.0, 1.0), i == 0),
           clearcoatNormal,
           clearcoatFactor,
           clearcoatRoughness,
@@ -1842,7 +1846,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
         );
         color += calculateDiffuseTransmissionLight(
           pbrInfo,
-          lighting_getDirectionalLight(i).color,
+          lighting_getDirectionalLight(i).color * select(1.0, clamp(directionalVisibility, 0.0, 1.0), i == 0),
           diffuseTransmissionColor,
           diffuseTransmission,
           multiscatterColor,
@@ -1861,7 +1865,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
         );
         color += calculateMaterialLightColor(
           pbrInfo,
-          lighting_getPointLight(i).color / attenuation,
+          lighting_getPointLight(i).color * select(1.0, clamp(pointVisibility[min(i, 3)], 0.0, 1.0), i < 4) / attenuation,
           clearcoatNormal,
           clearcoatFactor,
           clearcoatRoughness,
@@ -1872,7 +1876,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
         );
         color += calculateDiffuseTransmissionLight(
           pbrInfo,
-          lighting_getPointLight(i).color / attenuation,
+          lighting_getPointLight(i).color * select(1.0, clamp(pointVisibility[min(i, 3)], 0.0, 1.0), i < 4) / attenuation,
           diffuseTransmissionColor,
           diffuseTransmission,
           multiscatterColor,
@@ -1941,6 +1945,7 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
       }
     #endif
 
+    let indirectBaseColor = color;
     // Calculate lighting contribution from image based lighting source (IBL)
     #ifdef USE_IBL
     if (pbrMaterial.IBLenabled != 0) {
@@ -1975,6 +1980,8 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
       (1.0 - diffuseTransmission) * baseLayerEnergy * lightmapIrradiance / M_PI;
 #endif
 
+    color = indirectBaseColor + (color - indirectBaseColor) * pbr_ambientVisibility;
+
     // Apply optional PBR terms for additional (optional) shading
     #ifdef HAS_OCCLUSIONMAP
     if (pbrMaterial.occlusionMapEnabled != 0) {
@@ -2037,6 +2044,21 @@ fn pbr_filterColorWithSpotShadows(vertexColor: vec4<f32>, spotVisibility: vec4f)
   return vec4<f32>(applySceneColorManagement(color), alpha);
 }
 
+// Depth-only passes use the same base-color alpha, vertex color and UV transform.
+fn pbr_discardMaskedFragment(vertexColor: vec4f) {
+#ifdef ALPHA_CUTOFF
+  var alpha = pbrMaterial.baseColorFactor.a * vertexColor.a;
+#ifdef HAS_BASECOLORMAP
+  alpha *= textureSample(pbr_baseColorSampler, pbr_baseColorSamplerSampler, getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform)).a;
+#endif
+  if (alpha < pbrMaterial.alphaCutoff) {discard;}
+#endif
+}
+
+fn pbr_filterColorWithSpotShadows(vertexColor: vec4f, spotVisibility: vec4f) -> vec4f {
+  return pbr_filterColorWithShadows(vertexColor, 1.0, vec4f(1.0), spotVisibility);
+}
+
 fn pbr_filterColor(vertexColor: vec4<f32>) -> vec4<f32> {
   return pbr_filterColorWithSpotShadows(vertexColor, vec4f(1.0));
 }

package/src/modules/lighting/pbr-shadow/pbr-shadow.ts

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {NumberArray16} from '@math.gl/core';
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {pbrMaterial} from '../pbr-material/pbr-material';
+import {shadow} from '../shadow/shadow';
+
+export type PBRShadowProps = {
+  /** Receiver camera view matrix, used for directional cascade selection. */
+  viewMatrix?: Readonly<NumberArray16>;
+  /** Toggle receiving while retaining allocated maps and bindings. Defaults to true. */
+  enabled?: boolean;
+};
+
+export type PBRShadowUniforms = {
+  viewMatrix: Readonly<NumberArray16>;
+  enabled: number;
+};
+
+/** Applies shadow visibility to matching direct-light slots in the canonical PBR shader. */
+export const pbrShadow: ShaderModule<PBRShadowProps, PBRShadowUniforms> = {
+  name: 'pbrShadow',
+  dependencies: [pbrMaterial, shadow],
+  bindingLayout: [{name: 'pbrShadow', group: 0}],
+  uniformTypes: {viewMatrix: 'mat4x4<f32>', enabled: 'i32'},
+  defaultUniforms: {
+    viewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    enabled: 1
+  },
+  getUniforms(properties = {}) {
+    return {
+      ...(properties.viewMatrix ? {viewMatrix: properties.viewMatrix} : {}),
+      ...(properties.enabled === undefined ? {} : {enabled: Number(properties.enabled)})
+    };
+  },
+  source: /* wgsl */ `
+struct PBRShadowUniforms {
+  viewMatrix: mat4x4f,
+  enabled: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrShadow: PBRShadowUniforms;
+fn pbrShadow_filterColorWithDirectionalContact(vertexColor: vec4f, worldPosition: vec3f, worldNormal: vec3f, contactVisibility: f32) -> vec4f {
+  var directionalVisibility = 1.0;
+  var pointVisibility = vec4f(1.0);
+  var spotVisibility = vec4f(1.0);
+  if (pbrShadow.enabled != 0) {
+    let normal = normalize(worldNormal);
+    let viewDepth = -(pbrShadow.viewMatrix * vec4f(worldPosition, 1.0)).z;
+    directionalVisibility = shadow_getDirectionalFactor(worldPosition, normal, viewDepth);
+    for (var index = 0; index < 4; index++) {
+      pointVisibility[index] = shadow_getPointFactor(index, worldPosition, normal);
+      spotVisibility[index] = shadow_getSpotFactor(index, worldPosition, normal);
+    }
+  }
+  return pbr_filterColorWithShadows(vertexColor, min(directionalVisibility, contactVisibility), pointVisibility, spotVisibility);
+}
+fn pbrShadow_filterColor(vertexColor: vec4f, worldPosition: vec3f, worldNormal: vec3f) -> vec4f {
+  return pbrShadow_filterColorWithDirectionalContact(vertexColor, worldPosition, worldNormal, 1.0);
+}`,
+
+  fs: /* glsl */ `
+layout(std140) uniform pbrShadowUniforms {
+  mat4 viewMatrix;
+  int enabled;
+} pbrShadow;
+vec4 pbrShadow_filterColorWithDirectionalContact(vec4 vertexColor, vec3 worldPosition, vec3 worldNormal, float contactVisibility) {
+  float directionalVisibility = 1.0;
+  vec4 pointVisibility = vec4(1.0);
+  vec4 spotVisibility = vec4(1.0);
+  if (pbrShadow.enabled != 0) {
+    vec3 normal = normalize(worldNormal);
+    float viewDepth = -(pbrShadow.viewMatrix * vec4(worldPosition, 1.0)).z;
+    directionalVisibility = shadow_getDirectionalFactor(worldPosition, normal, viewDepth);
+    for (int index = 0; index < 4; index++) {
+      pointVisibility[index] = shadow_getPointFactor(index, worldPosition, normal);
+      spotVisibility[index] = shadow_getSpotFactor(index, worldPosition, normal);
+    }
+  }
+  return pbr_filterColorWithShadows(vertexColor, min(directionalVisibility, contactVisibility), pointVisibility, spotVisibility);
+ }
+vec4 pbrShadow_filterColor(vec4 vertexColor, vec3 worldPosition, vec3 worldNormal) {
+  return pbrShadow_filterColorWithDirectionalContact(vertexColor, worldPosition, worldNormal, 1.0);
+}`
+};

package/src/modules/lighting/pbr-surface/pbr-surface.ts

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {NumberArray16} from '@math.gl/core';
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {pbrMaterial} from '../pbr-material/pbr-material';
+
+export type PBRSurfaceProps = {
+  /** Rigid world-to-view camera transform. Defaults to identity. */
+  viewMatrix?: Readonly<NumberArray16>;
+  /** Include canonical normal/bump maps instead of geometric normals. Defaults to false. */
+  useMaterialNormals?: boolean;
+};
+
+export type PBRSurfaceUniforms = {
+  viewMatrix: Readonly<NumberArray16>;
+  useMaterialNormals: number;
+};
+
+/** Encodes view-space PBR normals in RGB; alpha one marks covered surface pixels. */
+export const pbrSurface: ShaderModule<PBRSurfaceProps, PBRSurfaceUniforms> = {
+  name: 'pbrSurface',
+  dependencies: [pbrMaterial],
+  bindingLayout: [{name: 'pbrSurface', group: 0}],
+  uniformTypes: {viewMatrix: 'mat4x4<f32>', useMaterialNormals: 'i32'},
+  defaultUniforms: {
+    viewMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
+    useMaterialNormals: 0
+  },
+  getUniforms(properties = {}) {
+    return {
+      ...(properties.viewMatrix ? {viewMatrix: properties.viewMatrix} : {}),
+      ...(properties.useMaterialNormals === undefined
+        ? {}
+        : {useMaterialNormals: Number(properties.useMaterialNormals)})
+    };
+  },
+  source: /* wgsl */ `
+struct PBRSurfaceUniforms {
+  viewMatrix: mat4x4f,
+  useMaterialNormals: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrSurface: PBRSurfaceUniforms;
+fn pbrSurface_getColor() -> vec4f {
+#ifdef HAS_NORMALS
+  var normal = normalize(fragmentInputs.pbr_vNormal);
+#ifdef DOUBLE_SIDED
+  if (!pbr_frontFacing) {normal = -normal;}
+#endif
+#else
+  var normal = normalize(cross(dpdy(fragmentInputs.pbr_vPosition), dpdx(fragmentInputs.pbr_vPosition)));
+#endif
+#ifdef HAS_NORMALMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    let coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#else
+#ifdef HAS_BUMPMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    let coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#endif
+#endif
+  let viewNormal = normalize((pbrSurface.viewMatrix * vec4f(normal, 0.0)).xyz);
+  return vec4f(viewNormal * 0.5 + vec3f(0.5), 1.0);
+}`,
+  fs: /* glsl */ `
+layout(std140) uniform pbrSurfaceUniforms {
+  mat4 viewMatrix;
+  int useMaterialNormals;
+} pbrSurface;
+vec4 pbrSurface_getColor() {
+#ifdef HAS_NORMALS
+#ifdef HAS_TANGENTS
+  vec3 normal = normalize(pbr_vTBN[2]);
+#else
+  vec3 normal = normalize(pbr_vNormal);
+#endif
+#ifdef DOUBLE_SIDED
+  if (!gl_FrontFacing) normal = -normal;
+#endif
+#else
+  vec3 normal = normalize(cross(dFdx(pbr_vPosition), dFdy(pbr_vPosition)));
+#endif
+#ifdef HAS_NORMALMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    vec2 coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#else
+#ifdef HAS_BUMPMAP
+  if (pbrSurface.useMaterialNormals != 0) {
+    vec2 coordinates = getMaterialUV(pbrMaterial.normalUVSet, pbrMaterial.normalUVTransform);
+    normal = getNormal(getTBN(coordinates), coordinates);
+  }
+#endif
+#endif
+  vec3 viewNormal = normalize((pbrSurface.viewMatrix * vec4(normal, 0.0)).xyz);
+  return vec4(viewNormal * 0.5 + 0.5, 1.0);
+}`
+};