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

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

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+/** Internal accumulation/copy/dilation shader shared by the engine baker. */
+export const 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;
+}`
+};
+//# sourceMappingURL=lightmap-filter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lightmap-filter.js","sourceRoot":"","sources":["../../../../src/modules/lighting/lightmap/lightmap-filter.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,4DAA4D;AAI5D,6EAA6E;AAC7E,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,aAAa,EAAE;QACb,EAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC,EAAC;QAClC,EAAC,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC,EAAC;QAClC,EAAC,IAAI,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC,EAAC;QACnC,EAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,EAAC;KACjC;IACD,YAAY,EAAE,EAAC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAC;IAC1C,eAAe,EAAE,EAAC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAC;IACrC,WAAW,EAAE,CAAC,KAAuC,EAAE,EAAE,CAAC,KAAK;IAC/D,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BR;IACA,EAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BJ;CACiG,CAAC"}

package/dist/modules/lighting/lightmap/lightmap.cjs

@@ -0,0 +1,89 @@
+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 lightmap_exports = {};
+__export(lightmap_exports, {
+  lightmapBake: () => lightmapBake
+});
+module.exports = __toCommonJS(lightmap_exports);
+var import_pbr_material = require("../pbr-material/pbr-material.cjs");
+const lightmapBake = {
+  name: "lightmapBake",
+  dependencies: [import_pbr_material.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;
+}
+`
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  lightmapBake
+});