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

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__;