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

package/LICENSE

@@ -8,16 +8,16 @@ Copyright (c) 2015 Uber Technologies, Inc.
 This software includes parts of PhiloGL (https://github.com/philogb/philogl)
 under MIT license. PhiloGL parts Copyright © 2013 Sencha Labs.
 
-This software includes adaptations of some postprocessing code from 
-THREE.js (https://github.com/mrdoob/three.js/) under MIT license. 
-THREE.js parts Copyright © 2010-2018 three.js authors. 
+This software includes adaptations of some postprocessing code from
+THREE.js (https://github.com/mrdoob/three.js/) under MIT license.
+THREE.js parts Copyright © 2010-2018 three.js authors.
 
 This software includes adaptations of Gaussian-splat rendering and
 level-of-detail behavior from Spark (https://github.com/sparkjsdev/spark)
 under MIT license.
 Spark parts Copyright © 2025 WORLD LABS TECHNOLOGIES, INC.
 
-Additional attribution given in specific source files. 
+Additional attribution given in specific source files.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,31 @@
+# Third-party notices: @luma.gl/shaders
+
+Shader composition by vis.gl contributors; historical Khronos PBR shaders, three.js half-float conversion, and Uber geospatial shader contributions.
+
+The [repository license](./LICENSE) retains historical project notices.
+See [References and credits](https://luma.gl/docs/references-and-credits) for people, research, standards, and assets.
+Separately installed dependencies retain their own licenses; this is not a transitive dependency inventory.
+
+## Khronos glTF-WebGL-PBR
+
+Copyright (c) 2016-2017 Mohamad Moneimne and Contributors.
+
+Source: [Khronos glTF-WebGL-PBR](https://github.com/KhronosGroup/glTF-Sample-Viewer/tree/88eda8c5358efe03128b72b6c5f5f6e5b6d023e1).
+
+Revision: historical import revision unknown unless explicitly identified below. Upstream license copies supplement retained source and repository notices.
+
+Adaptation: src/modules/lighting/pbr-material/pbr-material-glsl.ts and pbr-material-wgsl.ts adapt uniforms, lighting, extensions, and WGSL translation. The pinned historical MIT reference does not assert an exact original import revision. Later Apache terms do not replace this MIT version. The full upstream license includes its own third-party appendix; this does not mean the viewer GUI is bundled here.
+
+Full terms: [pbr](./licenses/pbr.txt).
+
+## three.js
+
+three.js authors.
+
+Source: [three.js](https://github.com/mrdoob/three.js).
+
+Revision: historical import revision unknown unless explicitly identified below. Upstream license copies supplement retained source and repository notices.
+
+Adaptation: src/modules/math/fp16/fp16-utils.ts adapts half-float conversion to TypeScript and math.gl clamp.
+
+Full terms: [three](./licenses/three.txt).

package/dist/dist.dev.js

@@ -86,6 +86,8 @@ var __exports__ = (() => {
     integrateSurfaceWeather: () => integrateSurfaceWeather,
     lambertMaterial: () => lambertMaterial,
     lighting: () => lighting,
+    lightmapBake: () => lightmapBake,
+    lightmapFilter: () => lightmapFilter,
     mergeShaderPluginModules: () => mergeShaderPluginModules,
     normalizeByteColor3: () => normalizeByteColor3,
     normalizeByteColor4: () => normalizeByteColor4,
@@ -1197,8 +1199,13 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
     }
     return decoded;
   }
+  var attributeShaderTypeInfoCache = /* @__PURE__ */ new Map();
   function getAttributeShaderTypeInfo(attributeType) {
     const resolvedAttributeType = resolveAttributeShaderTypeAlias(attributeType);
+    const cached = attributeShaderTypeInfoCache.get(resolvedAttributeType);
+    if (cached) {
+      return cached;
+    }
     const decoded = TYPE_INFO[resolvedAttributeType];
     if (!decoded) {
       throw new Error(`Unsupported attribute shader type: ${attributeType}`);
@@ -1207,13 +1214,15 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
     const integer = primitiveType === "i32" || primitiveType === "u32";
     const signed = primitiveType !== "u32";
     const byteLength = PRIMITIVE_TYPE_SIZES[primitiveType] * components;
-    return {
+    const result = Object.freeze({
       primitiveType,
       components,
       byteLength,
       integer,
       signed
-    };
+    });
+    attributeShaderTypeInfoCache.set(resolvedAttributeType, result);
+    return result;
   }
   var ShaderTypeDecoder = class {
     getVariableShaderTypeInfo(format) {
@@ -1322,6 +1331,9 @@ ${fragmentString}${source7.slice(insertionIndex)}`;
     "mat4x3<u32>": { type: "u32", components: 12 },
     "mat4x4<u32>": { type: "u32", components: 16 }
   };
+  for (const info of Object.values(UNIFORM_FORMATS)) {
+    Object.freeze(info);
+  }
   var WGSL_ATTRIBUTE_TYPE_ALIAS_MAP = {
     vec2i: "vec2<i32>",
     vec3i: "vec3<i32>",
@@ -21592,6 +21604,139 @@ void pbrAmbientOcclusion_setFactor(vec2 pixelPosition) {
 }`
     )
   };
+
+  // src/modules/lighting/lightmap/lightmap.ts
+  var 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;
+}
+`
+  };
+
+  // src/modules/lighting/lightmap/lightmap-filter.ts
+  var lightmapFilter = {
+    name: "lightmapFilter",
+    bindingLayout: [
+      { name: "lightmapFilter", group: 0 },
+      { name: "currentTexture", group: 0 },
+      { name: "previousTexture", group: 0 },
+      { name: "chartTexture", group: 0 }
+    ],
+    uniformTypes: { weight: "f32", mode: "i32" },
+    defaultUniforms: { weight: 1, mode: 0 },
+    getUniforms: (props) => props,
+    source: `
+struct LightmapFilterUniforms {weight: f32, mode: i32};
+@group(0) @binding(auto) var<uniform> lightmapFilter: LightmapFilterUniforms;
+@group(0) @binding(auto) var currentTexture: texture_2d<f32>;
+@group(0) @binding(auto) var previousTexture: texture_2d<f32>;
+@group(0) @binding(auto) var chartTexture: texture_2d<f32>;
+fn lightmapFilter_getColor(coordinates: vec2i) -> vec4f {
+  let current = textureLoad(currentTexture, coordinates, 0);
+  if (lightmapFilter.mode == 0) {
+    let previous = textureLoad(previousTexture, coordinates, 0);
+    return vec4f(mix(previous.rgb, current.rgb, lightmapFilter.weight), current.a);
+  }
+  if (lightmapFilter.mode == 2 || current.a > 0.0) {return current;}
+  let chart = textureLoad(chartTexture, coordinates, 0).r;
+  if (chart <= 0.0) {return current;}
+  let size = vec2i(textureDimensions(currentTexture));
+  for (var y = -1; y <= 1; y++) {
+    for (var x = -1; x <= 1; x++) {
+      let neighbor = coordinates + vec2i(x, y);
+      if (all(neighbor >= vec2i(0)) && all(neighbor < size)) {
+        let candidate = textureLoad(currentTexture, neighbor, 0);
+        if (candidate.a == chart) {return candidate;}
+      }
+    }
+  }
+  return current;
+}`,
+    fs: `
+layout(std140) uniform lightmapFilterUniforms {
+ float weight;
+ int mode;
+} lightmapFilter;
+uniform sampler2D currentTexture;
+uniform sampler2D previousTexture;
+uniform sampler2D chartTexture;
+vec4 lightmapFilter_getColor(ivec2 coordinates) {
+  vec4 current = texelFetch(currentTexture, coordinates, 0);
+  if (lightmapFilter.mode == 0) {
+    return vec4(mix(texelFetch(previousTexture, coordinates, 0).rgb, current.rgb, lightmapFilter.weight), current.a);
+  }
+  if (lightmapFilter.mode == 2 || current.a > 0.0) {return current;}
+  float chart = texelFetch(chartTexture, coordinates, 0).r;
+  ivec2 size = textureSize(currentTexture, 0);
+  if (chart <= 0.0) return current;
+  for (int y = -1; y <= 1; y++) {
+    for (int x = -1; x <= 1; x++) {
+      ivec2 neighbor = coordinates + ivec2(x,y);
+      if (all(greaterThanEqual(neighbor, ivec2(0))) && all(lessThan(neighbor,size))) {
+        vec4 candidate = texelFetch(currentTexture, neighbor, 0);
+        if (candidate.a == chart) {return candidate;}
+      }
+    }
+  }
+  return current;
+}`
+  };
   return __toCommonJS(bundle_exports);
 })();
       return __exports__;