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

package/dist/modules/lighting/lightmap/lightmap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lightmap.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/lightmap/lightmap.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAC,YAAY,EAAC,oDAAiD;AAG3E,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,wHAAwH;AACxH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAMF,OAAO,CAAC,oBAAoB,CAAC;;;;CAuDkC,CAAC"}

package/dist/modules/lighting/lightmap/lightmap.js

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { pbrMaterial } from "../pbr-material/pbr-material.js";
+/** Texture-space rasterization controls. Chart IDs are positive integers exactly representable in the target format. */
+export const lightmapBake = {
+    name: 'lightmapBake',
+    dependencies: [pbrMaterial],
+    bindingLayout: [{ name: 'lightmapBake', group: 0 }],
+    uniformTypes: { uvSet: 'i32', uvTransform: 'mat3x3<f32>', chartId: 'f32' },
+    defaultUniforms: { uvSet: 1, uvTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1], chartId: 1 },
+    getUniforms: (props) => props,
+    source: `
+struct LightmapBakeUniforms {uvSet: i32, uvTransform: mat3x3f, chartId: f32};
+@group(0) @binding(auto) var<uniform> lightmapBake: LightmapBakeUniforms;
+
+fn lightmap_getIrradiance(position: vec3f, normal: vec3f, directionalVisibility: f32, pointVisibility: vec4f, spotVisibility: vec4f) -> vec3f {
+  if (lighting.enabled == 0) {return vec3f(0.0);}
+  var irradiance = lighting.ambientColor;
+  for (var index = 0; index < lighting.directionalLightCount; index++) {
+    let light = lighting_getDirectionalLight(index);
+    irradiance += light.color * max(dot(normal, -normalize(light.direction)), 0.0) * select(1.0, directionalVisibility, index == 0);
+  }
+  for (var index = 0; index < lighting.pointLightCount; index++) {
+    let light = lighting_getPointLight(index);
+    let offset = light.position - position;
+    let visibility = select(1.0, pointVisibility[min(index, 3)], index < 4);
+    irradiance += light.color * max(dot(normal, normalize(offset)), 0.0) * visibility / max(getPointLightAttenuation(light, length(offset)), 0.0001);
+  }
+  for (var index = 0; index < lighting.spotLightCount; index++) {
+    let light = lighting_getSpotLight(index);
+    irradiance += light.color * max(dot(normal, normalize(light.position - position)), 0.0) * select(1.0, spotVisibility[min(index, 3)], index < 4) / max(getSpotLightAttenuation(light, position), 0.0001);
+  }
+  return irradiance;
+}
+`,
+    vs: `layout(std140) uniform lightmapBakeUniforms {
+ int uvSet;
+ mat3 uvTransform;
+ float chartId;
+} lightmapBake;`,
+    fs: `layout(std140) uniform lightmapBakeUniforms {
+ int uvSet;
+ mat3 uvTransform;
+ float chartId;
+} lightmapBake;
+
+vec3 lightmap_getIrradiance(vec3 position, vec3 normal, float directionalVisibility, vec4 pointVisibility, vec4 spotVisibility) {
+  if (lighting.enabled == 0) {return vec3(0.0);}
+  vec3 irradiance = lighting.ambientColor;
+  for (int index = 0; index < lighting.directionalLightCount; index++) {
+    DirectionalLight light = lighting_getDirectionalLight(index);
+    irradiance += light.color * max(dot(normal, -normalize(light.direction)), 0.0) * (index == 0 ? directionalVisibility : 1.0);
+  }
+  for (int index = 0; index < lighting.pointLightCount; index++) {
+    PointLight light = lighting_getPointLight(index);
+    vec3 offset = light.position - position;
+    irradiance += light.color * max(dot(normal, normalize(offset)), 0.0) * (index < 4 ? pointVisibility[index] : 1.0) / max(getPointLightAttenuation(light, length(offset)), 0.0001);
+  }
+  for (int index = 0; index < lighting.spotLightCount; index++) {
+    SpotLight light = lighting_getSpotLight(index);
+    irradiance += light.color * max(dot(normal, normalize(light.position - position)), 0.0) * (index < 4 ? spotVisibility[index] : 1.0) / max(getSpotLightAttenuation(light, position), 0.0001);
+  }
+  return irradiance;
+}
+`
+};
+//# sourceMappingURL=lightmap.js.map

package/dist/modules/lighting/lightmap/lightmap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lightmap.js","sourceRoot":"","sources":["../../../../src/modules/lighting/lightmap/lightmap.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,4DAA4D;AAI5D,OAAO,EAAC,WAAW,EAAC,wCAAqC;AAQzD,wHAAwH;AACxH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,YAAY,EAAE,CAAC,WAAW,CAAC;IAC3B,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IACjD,YAAY,EAAE,EAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,OAAO,EAAE,KAAK,EAAC;IACxE,eAAe,EAAE,EAAC,KAAK,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAC;IACjF,WAAW,EAAE,CAAC,KAAoC,EAAE,EAAE,CAAC,KAAK;IAC5D,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;CAuBT;IACC,EAAE,EAAE;;;;gBAIU;IACd,EAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;CAwBL;CACqF,CAAC"}

package/dist/modules/lighting/pbr-ambient-occlusion/pbr-ambient-occlusion.cjs

@@ -0,0 +1,87 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pbr_ambient_occlusion_exports = {};
+__export(pbr_ambient_occlusion_exports, {
+  pbrAmbientOcclusion: () => pbrAmbientOcclusion
+});
+module.exports = __toCommonJS(pbr_ambient_occlusion_exports);
+var import_pbr_material = require("../pbr-material/pbr-material.cjs");
+const pbrAmbientOcclusion = {
+  name: "pbrAmbientOcclusion",
+  dependencies: [import_pbr_material.pbrMaterial],
+  bindingLayout: [
+    { name: "pbrAmbientOcclusion", group: 0 },
+    { name: "ambientOcclusionTexture", group: 2 }
+  ],
+  uniformTypes: { viewport: "vec4<f32>", strength: "f32", enabled: "i32" },
+  defaultUniforms: { viewport: [0, 0, 1, 1], strength: 1, enabled: 1 },
+  getUniforms(properties = {}) {
+    return {
+      ...properties.viewport ? { viewport: properties.viewport } : {},
+      ...properties.strength === void 0 ? {} : { strength: properties.strength },
+      ...properties.enabled === void 0 ? {} : { enabled: Number(properties.enabled) },
+      ...properties.ambientOcclusionTexture ? { ambientOcclusionTexture: properties.ambientOcclusionTexture } : {}
+    };
+  },
+  source: (
+    /* wgsl */
+    `
+struct PBRAmbientOcclusionUniforms {
+  viewport: vec4f,
+  strength: f32,
+  enabled: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrAmbientOcclusion: PBRAmbientOcclusionUniforms;
+@group(2) @binding(auto) var ambientOcclusionTexture: texture_2d<f32>;
+@group(2) @binding(auto) var ambientOcclusionTextureSampler: sampler;
+fn pbrAmbientOcclusion_getFactor(pixelPosition:vec2f)->f32 {
+  if(pbrAmbientOcclusion.enabled==0){return 1.0;}
+  let coordinates=(pixelPosition-pbrAmbientOcclusion.viewport.xy)/pbrAmbientOcclusion.viewport.zw;
+  if(any(coordinates<vec2f(0.0))||any(coordinates>vec2f(1.0))){return 1.0;}
+  let visibility=textureSampleLevel(ambientOcclusionTexture,ambientOcclusionTextureSampler,coordinates,0.0).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrAmbientOcclusion.strength,0.0,1.0));
+}
+fn pbrAmbientOcclusion_setFactor(pixelPosition:vec2f) {
+  pbr_ambientVisibility = pbrAmbientOcclusion_getFactor(pixelPosition);
+}`
+  ),
+  fs: (
+    /* glsl */
+    `
+layout(std140) uniform pbrAmbientOcclusionUniforms {
+  vec4 viewport;
+  float strength;
+  int enabled;
+} pbrAmbientOcclusion;
+uniform sampler2D ambientOcclusionTexture;
+float pbrAmbientOcclusion_getFactor(vec2 pixelPosition) {
+  if(pbrAmbientOcclusion.enabled==0)return 1.0;
+  vec2 coordinates=(pixelPosition-pbrAmbientOcclusion.viewport.xy)/pbrAmbientOcclusion.viewport.zw;
+  if(any(lessThan(coordinates,vec2(0.0)))||any(greaterThan(coordinates,vec2(1.0))))return 1.0;
+  float visibility=texture(ambientOcclusionTexture,coordinates).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrAmbientOcclusion.strength,0.0,1.0));
+}
+void pbrAmbientOcclusion_setFactor(vec2 pixelPosition) {
+  pbr_ambientVisibility = pbrAmbientOcclusion_getFactor(pixelPosition);
+}`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pbrAmbientOcclusion
+});

package/dist/modules/lighting/pbr-ambient-occlusion/pbr-ambient-occlusion.d.ts

@@ -0,0 +1,21 @@
+import type { NumberArray4 } from '@math.gl/core';
+import type { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+export type PBRAmbientOcclusionProps<TextureT = unknown> = {
+    ambientOcclusionTexture?: TextureT;
+    /** Origin and dimensions of the receiver viewport, in physical pixels. */
+    viewport?: Readonly<NumberArray4>;
+    strength?: number;
+    enabled?: boolean;
+};
+type AmbientUniforms = {
+    viewport: Readonly<NumberArray4>;
+    strength: number;
+    enabled: number;
+};
+type AmbientBindings<TextureT = unknown> = {
+    ambientOcclusionTexture?: TextureT;
+};
+/** Sets ambient visibility for the canonical PBR material; direct lighting and emission remain independent. */
+export declare const pbrAmbientOcclusion: ShaderModule<PBRAmbientOcclusionProps, AmbientUniforms, AmbientBindings>;
+export {};
+//# sourceMappingURL=pbr-ambient-occlusion.d.ts.map

package/dist/modules/lighting/pbr-ambient-occlusion/pbr-ambient-occlusion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-ambient-occlusion.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/pbr-ambient-occlusion/pbr-ambient-occlusion.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAC,YAAY,EAAC,oDAAiD;AAG3E,MAAM,MAAM,wBAAwB,CAAC,QAAQ,GAAG,OAAO,IAAI;IACzD,uBAAuB,CAAC,EAAE,QAAQ,CAAC;IACnC,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AACF,KAAK,eAAe,GAAG;IAAC,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC;AAC7F,KAAK,eAAe,CAAC,QAAQ,GAAG,OAAO,IAAI;IAAC,uBAAuB,CAAC,EAAE,QAAQ,CAAA;CAAC,CAAC;AAEhF,+GAA+G;AAC/G,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAC5C,wBAAwB,EACxB,eAAe,EACf,eAAe,CAwDhB,CAAC"}

package/dist/modules/lighting/pbr-ambient-occlusion/pbr-ambient-occlusion.js

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { pbrMaterial } from "../pbr-material/pbr-material.js";
+/** Sets ambient visibility for the canonical PBR material; direct lighting and emission remain independent. */
+export const pbrAmbientOcclusion = {
+    name: 'pbrAmbientOcclusion',
+    dependencies: [pbrMaterial],
+    bindingLayout: [
+        { name: 'pbrAmbientOcclusion', group: 0 },
+        { name: 'ambientOcclusionTexture', group: 2 }
+    ],
+    uniformTypes: { viewport: 'vec4<f32>', strength: 'f32', enabled: 'i32' },
+    defaultUniforms: { viewport: [0, 0, 1, 1], strength: 1, enabled: 1 },
+    getUniforms(properties = {}) {
+        return {
+            ...(properties.viewport ? { viewport: properties.viewport } : {}),
+            ...(properties.strength === undefined ? {} : { strength: properties.strength }),
+            ...(properties.enabled === undefined ? {} : { enabled: Number(properties.enabled) }),
+            ...(properties.ambientOcclusionTexture
+                ? { ambientOcclusionTexture: properties.ambientOcclusionTexture }
+                : {})
+        };
+    },
+    source: /* wgsl */ `
+struct PBRAmbientOcclusionUniforms {
+  viewport: vec4f,
+  strength: f32,
+  enabled: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrAmbientOcclusion: PBRAmbientOcclusionUniforms;
+@group(2) @binding(auto) var ambientOcclusionTexture: texture_2d<f32>;
+@group(2) @binding(auto) var ambientOcclusionTextureSampler: sampler;
+fn pbrAmbientOcclusion_getFactor(pixelPosition:vec2f)->f32 {
+  if(pbrAmbientOcclusion.enabled==0){return 1.0;}
+  let coordinates=(pixelPosition-pbrAmbientOcclusion.viewport.xy)/pbrAmbientOcclusion.viewport.zw;
+  if(any(coordinates<vec2f(0.0))||any(coordinates>vec2f(1.0))){return 1.0;}
+  let visibility=textureSampleLevel(ambientOcclusionTexture,ambientOcclusionTextureSampler,coordinates,0.0).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrAmbientOcclusion.strength,0.0,1.0));
+}
+fn pbrAmbientOcclusion_setFactor(pixelPosition:vec2f) {
+  pbr_ambientVisibility = pbrAmbientOcclusion_getFactor(pixelPosition);
+}`,
+    fs: /* glsl */ `
+layout(std140) uniform pbrAmbientOcclusionUniforms {
+  vec4 viewport;
+  float strength;
+  int enabled;
+} pbrAmbientOcclusion;
+uniform sampler2D ambientOcclusionTexture;
+float pbrAmbientOcclusion_getFactor(vec2 pixelPosition) {
+  if(pbrAmbientOcclusion.enabled==0)return 1.0;
+  vec2 coordinates=(pixelPosition-pbrAmbientOcclusion.viewport.xy)/pbrAmbientOcclusion.viewport.zw;
+  if(any(lessThan(coordinates,vec2(0.0)))||any(greaterThan(coordinates,vec2(1.0))))return 1.0;
+  float visibility=texture(ambientOcclusionTexture,coordinates).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrAmbientOcclusion.strength,0.0,1.0));
+}
+void pbrAmbientOcclusion_setFactor(vec2 pixelPosition) {
+  pbr_ambientVisibility = pbrAmbientOcclusion_getFactor(pixelPosition);
+}`
+};
+//# sourceMappingURL=pbr-ambient-occlusion.js.map

package/dist/modules/lighting/pbr-ambient-occlusion/pbr-ambient-occlusion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-ambient-occlusion.js","sourceRoot":"","sources":["../../../../src/modules/lighting/pbr-ambient-occlusion/pbr-ambient-occlusion.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,4DAA4D;AAI5D,OAAO,EAAC,WAAW,EAAC,wCAAqC;AAYzD,+GAA+G;AAC/G,MAAM,CAAC,MAAM,mBAAmB,GAI5B;IACF,IAAI,EAAE,qBAAqB;IAC3B,YAAY,EAAE,CAAC,WAAW,CAAC;IAC3B,aAAa,EAAE;QACb,EAAC,IAAI,EAAE,qBAAqB,EAAE,KAAK,EAAE,CAAC,EAAC;QACvC,EAAC,IAAI,EAAE,yBAAyB,EAAE,KAAK,EAAE,CAAC,EAAC;KAC5C;IACD,YAAY,EAAE,EAAC,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAC;IACtE,eAAe,EAAE,EAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAC;IAClE,WAAW,CAAC,UAAU,GAAG,EAAE;QACzB,OAAO;YACL,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAC,QAAQ,EAAE,UAAU,CAAC,QAAQ,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/D,GAAG,CAAC,UAAU,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAC,QAAQ,EAAE,UAAU,CAAC,QAAQ,EAAC,CAAC;YAC7E,GAAG,CAAC,UAAU,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAC,OAAO,EAAE,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,EAAC,CAAC;YAClF,GAAG,CAAC,UAAU,CAAC,uBAAuB;gBACpC,CAAC,CAAC,EAAC,uBAAuB,EAAE,UAAU,CAAC,uBAAuB,EAAC;gBAC/D,CAAC,CAAC,EAAE,CAAC;SACR,CAAC;IACJ,CAAC;IACD,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;EAkBnB;IACA,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;EAgBf;CACD,CAAC"}

package/dist/modules/lighting/pbr-contact-shadow/pbr-contact-shadow.cjs

@@ -0,0 +1,87 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pbr_contact_shadow_exports = {};
+__export(pbr_contact_shadow_exports, {
+  pbrContactShadow: () => pbrContactShadow
+});
+module.exports = __toCommonJS(pbr_contact_shadow_exports);
+var import_pbr_material = require("../pbr-material/pbr-material.cjs");
+const pbrContactShadow = {
+  name: "pbrContactShadow",
+  dependencies: [import_pbr_material.pbrMaterial],
+  bindingLayout: [
+    { name: "pbrContactShadow", group: 0 },
+    { name: "contactShadowTexture", group: 2 }
+  ],
+  uniformTypes: { viewport: "vec4<f32>", strength: "f32", enabled: "i32" },
+  defaultUniforms: { viewport: [0, 0, 1, 1], strength: 1, enabled: 1 },
+  getUniforms(properties = {}) {
+    return {
+      ...properties.viewport ? { viewport: properties.viewport } : {},
+      ...properties.strength === void 0 ? {} : { strength: properties.strength },
+      ...properties.enabled === void 0 ? {} : { enabled: Number(properties.enabled) },
+      ...properties.contactShadowTexture ? { contactShadowTexture: properties.contactShadowTexture } : {}
+    };
+  },
+  source: (
+    /* wgsl */
+    `
+struct PBRContactShadowUniforms {
+  viewport: vec4f,
+  strength: f32,
+  enabled: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrContactShadow: PBRContactShadowUniforms;
+@group(2) @binding(auto) var contactShadowTexture: texture_2d<f32>;
+@group(2) @binding(auto) var contactShadowTextureSampler: sampler;
+fn pbrContactShadow_getFactor(pixelPosition:vec2f)->f32 {
+  if(pbrContactShadow.enabled==0){return 1.0;}
+  let coordinates=(pixelPosition-pbrContactShadow.viewport.xy)/pbrContactShadow.viewport.zw;
+  if(any(coordinates<vec2f(0.0))||any(coordinates>vec2f(1.0))){return 1.0;}
+  let visibility=textureSampleLevel(contactShadowTexture,contactShadowTextureSampler,coordinates,0.0).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrContactShadow.strength,0.0,1.0));
+}
+fn pbrContactShadow_filterColor(vertexColor:vec4f,pixelPosition:vec2f)->vec4f {
+  return pbr_filterColorWithShadows(vertexColor,pbrContactShadow_getFactor(pixelPosition),vec4f(1.0),vec4f(1.0));
+}`
+  ),
+  fs: (
+    /* glsl */
+    `
+layout(std140) uniform pbrContactShadowUniforms {
+  vec4 viewport;
+  float strength;
+  int enabled;
+} pbrContactShadow;
+uniform sampler2D contactShadowTexture;
+float pbrContactShadow_getFactor(vec2 pixelPosition) {
+  if(pbrContactShadow.enabled==0)return 1.0;
+  vec2 coordinates=(pixelPosition-pbrContactShadow.viewport.xy)/pbrContactShadow.viewport.zw;
+  if(any(lessThan(coordinates,vec2(0.0)))||any(greaterThan(coordinates,vec2(1.0))))return 1.0;
+  float visibility=texture(contactShadowTexture,coordinates).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrContactShadow.strength,0.0,1.0));
+}
+vec4 pbrContactShadow_filterColor(vec4 vertexColor,vec2 pixelPosition) {
+  return pbr_filterColorWithShadows(vertexColor,pbrContactShadow_getFactor(pixelPosition),vec4(1.0),vec4(1.0));
+}`
+  )
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pbrContactShadow
+});

package/dist/modules/lighting/pbr-contact-shadow/pbr-contact-shadow.d.ts

@@ -0,0 +1,21 @@
+import type { NumberArray4 } from '@math.gl/core';
+import type { ShaderModule } from "../../../lib/shader-module/shader-module.js";
+export type PBRContactShadowProps<TextureT = unknown> = {
+    contactShadowTexture?: TextureT;
+    /** Origin and dimensions of the receiver viewport, in physical pixels. */
+    viewport?: Readonly<NumberArray4>;
+    strength?: number;
+    enabled?: boolean;
+};
+type ContactUniforms = {
+    viewport: Readonly<NumberArray4>;
+    strength: number;
+    enabled: number;
+};
+type ContactBindings<TextureT = unknown> = {
+    contactShadowTexture?: TextureT;
+};
+/** Applies a screen-space visibility mask to the first directional light only. */
+export declare const pbrContactShadow: ShaderModule<PBRContactShadowProps, ContactUniforms, ContactBindings>;
+export {};
+//# sourceMappingURL=pbr-contact-shadow.d.ts.map

package/dist/modules/lighting/pbr-contact-shadow/pbr-contact-shadow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-contact-shadow.d.ts","sourceRoot":"","sources":["../../../../src/modules/lighting/pbr-contact-shadow/pbr-contact-shadow.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAC,YAAY,EAAC,oDAAiD;AAG3E,MAAM,MAAM,qBAAqB,CAAC,QAAQ,GAAG,OAAO,IAAI;IACtD,oBAAoB,CAAC,EAAE,QAAQ,CAAC;IAChC,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AACF,KAAK,eAAe,GAAG;IAAC,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC;AAC7F,KAAK,eAAe,CAAC,QAAQ,GAAG,OAAO,IAAI;IAAC,oBAAoB,CAAC,EAAE,QAAQ,CAAA;CAAC,CAAC;AAE7E,kFAAkF;AAClF,eAAO,MAAM,gBAAgB,EAAE,YAAY,CACzC,qBAAqB,EACrB,eAAe,EACf,eAAe,CAwDhB,CAAC"}

package/dist/modules/lighting/pbr-contact-shadow/pbr-contact-shadow.js

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import { pbrMaterial } from "../pbr-material/pbr-material.js";
+/** Applies a screen-space visibility mask to the first directional light only. */
+export const pbrContactShadow = {
+    name: 'pbrContactShadow',
+    dependencies: [pbrMaterial],
+    bindingLayout: [
+        { name: 'pbrContactShadow', group: 0 },
+        { name: 'contactShadowTexture', group: 2 }
+    ],
+    uniformTypes: { viewport: 'vec4<f32>', strength: 'f32', enabled: 'i32' },
+    defaultUniforms: { viewport: [0, 0, 1, 1], strength: 1, enabled: 1 },
+    getUniforms(properties = {}) {
+        return {
+            ...(properties.viewport ? { viewport: properties.viewport } : {}),
+            ...(properties.strength === undefined ? {} : { strength: properties.strength }),
+            ...(properties.enabled === undefined ? {} : { enabled: Number(properties.enabled) }),
+            ...(properties.contactShadowTexture
+                ? { contactShadowTexture: properties.contactShadowTexture }
+                : {})
+        };
+    },
+    source: /* wgsl */ `
+struct PBRContactShadowUniforms {
+  viewport: vec4f,
+  strength: f32,
+  enabled: i32,
+};
+@group(0) @binding(auto) var<uniform> pbrContactShadow: PBRContactShadowUniforms;
+@group(2) @binding(auto) var contactShadowTexture: texture_2d<f32>;
+@group(2) @binding(auto) var contactShadowTextureSampler: sampler;
+fn pbrContactShadow_getFactor(pixelPosition:vec2f)->f32 {
+  if(pbrContactShadow.enabled==0){return 1.0;}
+  let coordinates=(pixelPosition-pbrContactShadow.viewport.xy)/pbrContactShadow.viewport.zw;
+  if(any(coordinates<vec2f(0.0))||any(coordinates>vec2f(1.0))){return 1.0;}
+  let visibility=textureSampleLevel(contactShadowTexture,contactShadowTextureSampler,coordinates,0.0).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrContactShadow.strength,0.0,1.0));
+}
+fn pbrContactShadow_filterColor(vertexColor:vec4f,pixelPosition:vec2f)->vec4f {
+  return pbr_filterColorWithShadows(vertexColor,pbrContactShadow_getFactor(pixelPosition),vec4f(1.0),vec4f(1.0));
+}`,
+    fs: /* glsl */ `
+layout(std140) uniform pbrContactShadowUniforms {
+  vec4 viewport;
+  float strength;
+  int enabled;
+} pbrContactShadow;
+uniform sampler2D contactShadowTexture;
+float pbrContactShadow_getFactor(vec2 pixelPosition) {
+  if(pbrContactShadow.enabled==0)return 1.0;
+  vec2 coordinates=(pixelPosition-pbrContactShadow.viewport.xy)/pbrContactShadow.viewport.zw;
+  if(any(lessThan(coordinates,vec2(0.0)))||any(greaterThan(coordinates,vec2(1.0))))return 1.0;
+  float visibility=texture(contactShadowTexture,coordinates).r;
+  return mix(1.0,clamp(visibility,0.0,1.0),clamp(pbrContactShadow.strength,0.0,1.0));
+}
+vec4 pbrContactShadow_filterColor(vec4 vertexColor,vec2 pixelPosition) {
+  return pbr_filterColorWithShadows(vertexColor,pbrContactShadow_getFactor(pixelPosition),vec4(1.0),vec4(1.0));
+}`
+};
+//# sourceMappingURL=pbr-contact-shadow.js.map

package/dist/modules/lighting/pbr-contact-shadow/pbr-contact-shadow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-contact-shadow.js","sourceRoot":"","sources":["../../../../src/modules/lighting/pbr-contact-shadow/pbr-contact-shadow.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,4DAA4D;AAI5D,OAAO,EAAC,WAAW,EAAC,wCAAqC;AAYzD,kFAAkF;AAClF,MAAM,CAAC,MAAM,gBAAgB,GAIzB;IACF,IAAI,EAAE,kBAAkB;IACxB,YAAY,EAAE,CAAC,WAAW,CAAC;IAC3B,aAAa,EAAE;QACb,EAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC,EAAC;QACpC,EAAC,IAAI,EAAE,sBAAsB,EAAE,KAAK,EAAE,CAAC,EAAC;KACzC;IACD,YAAY,EAAE,EAAC,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAC;IACtE,eAAe,EAAE,EAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAC;IAClE,WAAW,CAAC,UAAU,GAAG,EAAE;QACzB,OAAO;YACL,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAC,QAAQ,EAAE,UAAU,CAAC,QAAQ,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/D,GAAG,CAAC,UAAU,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAC,QAAQ,EAAE,UAAU,CAAC,QAAQ,EAAC,CAAC;YAC7E,GAAG,CAAC,UAAU,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAC,OAAO,EAAE,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,EAAC,CAAC;YAClF,GAAG,CAAC,UAAU,CAAC,oBAAoB;gBACjC,CAAC,CAAC,EAAC,oBAAoB,EAAE,UAAU,CAAC,oBAAoB,EAAC;gBACzD,CAAC,CAAC,EAAE,CAAC;SACR,CAAC;IACJ,CAAC;IACD,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;EAkBnB;IACA,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;EAgBf;CACD,CAAC"}

package/dist/modules/lighting/pbr-material/pbr-material-glsl.cjs

@@ -53,7 +53,7 @@ void pbr_setPositionNormalTangentUV(
   vec3 bitangentW = cross(normalW, tangentW) * tangent.w;
   pbr_vTBN = mat3(tangentW, bitangentW, normalW);
 #else // HAS_TANGENTS != 1
-  pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
+  pbr_vNormal = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
 #endif
 #endif
 
@@ -1060,7 +1060,9 @@ vec3 calculateFinalColor(PBRInfo pbrInfo, vec3 lightColor) {
 }
 
 // Visibility for the first four spotlights; environment and other lights are unaffected.
-vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
+float pbr_ambientVisibility = 1.0;
+
+vec4 pbr_filterColorWithShadows(vec4 vertexColor, float directionalVisibility, vec4 pointVisibility, vec4 spotVisibility)
 {
   vec2 baseColorUV = getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform);
   vec2 metallicRoughnessUV = getMaterialUV(
@@ -1156,7 +1158,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
     color.rgb = baseColor.rgb;
 #ifdef HAS_LIGHTMAP
     if (pbrMaterial.lightmapMapEnabled) {
-      color *= lightmapIrradiance / M_PI;
+      color *= lightmapIrradiance / M_PI * pbr_ambientVisibility;
 #ifdef HAS_OCCLUSIONMAP
       if (pbrMaterial.occlusionMapEnabled) {
         float ao = texture(pbr_occlusionSampler, occlusionUV).r;
@@ -1258,12 +1260,12 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
 
 #ifdef USE_LIGHTS
       PBRInfo_setAmbientLight(pbrInfo);
-      color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+      color += calculateFinalColor(pbrInfo, lighting.ambientColor * pbr_ambientVisibility);
 
       for(int 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 * (i == 0 ? clamp(directionalVisibility, 0.0, 1.0) : 1.0));
         }
       }
 
@@ -1271,7 +1273,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
         if (i < lighting.pointLightCount) {
           PBRInfo_setPointLight(pbrInfo, lighting_getPointLight(i));
           float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
-          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+          color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color * (i < 4 ? clamp(pointVisibility[min(i, 3)], 0.0, 1.0) : 1.0) / attenuation);
         }
       }
 
@@ -1297,6 +1299,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
       }
 #endif
 
+vec3 indirectBaseColor = color;
 #ifdef USE_IBL
       if (pbrMaterial.IBLenabled) {
         color += getIBLContribution(pbrInfo, n, reflection);
@@ -1305,6 +1308,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
 
       // 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) {
@@ -1537,7 +1541,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
     PBRInfo_setAmbientLight(pbrInfo);
     color += calculateMaterialLightColor(
       pbrInfo,
-      lighting.ambientColor,
+      lighting.ambientColor * pbr_ambientVisibility,
       clearcoatNormal,
       clearcoatFactor,
       clearcoatRoughness,
@@ -1553,7 +1557,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
         PBRInfo_setDirectionalLight(pbrInfo, -lighting_getDirectionalLight(i).direction);
         color += calculateMaterialLightColor(
           pbrInfo,
-          lighting_getDirectionalLight(i).color,
+          lighting_getDirectionalLight(i).color * (i == 0 ? clamp(directionalVisibility, 0.0, 1.0) : 1.0),
           clearcoatNormal,
           clearcoatFactor,
           clearcoatRoughness,
@@ -1564,7 +1568,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
         );
         color += calculateDiffuseTransmissionLight(
           pbrInfo,
-          lighting_getDirectionalLight(i).color,
+          lighting_getDirectionalLight(i).color * (i == 0 ? clamp(directionalVisibility, 0.0, 1.0) : 1.0),
           diffuseTransmissionColor,
           diffuseTransmission,
           multiscatterColor,
@@ -1580,7 +1584,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
         float attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
         color += calculateMaterialLightColor(
           pbrInfo,
-          lighting_getPointLight(i).color / attenuation,
+          lighting_getPointLight(i).color * (i < 4 ? clamp(pointVisibility[min(i, 3)], 0.0, 1.0) : 1.0) / attenuation,
           clearcoatNormal,
           clearcoatFactor,
           clearcoatRoughness,
@@ -1591,7 +1595,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
         );
         color += calculateDiffuseTransmissionLight(
           pbrInfo,
-          lighting_getPointLight(i).color / attenuation,
+          lighting_getPointLight(i).color * (i < 4 ? clamp(pointVisibility[min(i, 3)], 0.0, 1.0) : 1.0) / attenuation,
           diffuseTransmissionColor,
           diffuseTransmission,
           multiscatterColor,
@@ -1660,6 +1664,7 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
       }
 #endif
 
+    vec3 indirectBaseColor = color;
     // Calculate lighting contribution from image based lighting source (IBL)
 #ifdef USE_IBL
     if (pbrMaterial.IBLenabled) {
@@ -1694,6 +1699,8 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
       (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) {
@@ -1755,6 +1762,21 @@ vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility)
   return vec4(applySceneColorManagement(color), alpha);
 }
 
+// Depth-only passes use the same base-color alpha, vertex color and UV transform.
+void pbr_discardMaskedFragment(vec4 vertexColor) {
+#ifdef ALPHA_CUTOFF
+  float alpha = pbrMaterial.baseColorFactor.a * vertexColor.a;
+#ifdef HAS_BASECOLORMAP
+  alpha *= texture(pbr_baseColorSampler, getMaterialUV(pbrMaterial.baseColorUVSet, pbrMaterial.baseColorUVTransform)).a;
+#endif
+  if (alpha < pbrMaterial.alphaCutoff) {discard;}
+#endif
+}
+
+vec4 pbr_filterColorWithSpotShadows(vec4 vertexColor, vec4 spotVisibility) {
+  return pbr_filterColorWithShadows(vertexColor, 1.0, vec4(1.0), spotVisibility);
+}
+
 vec4 pbr_filterColor(vec4 vertexColor) {
   return pbr_filterColorWithSpotShadows(vertexColor, vec4(1.0));
 }