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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/shaders",
-  "version": "10.0.0-alpha.11",
+  "version": "10.0.0-alpha.12",
   "description": "Shader module system for luma.gl",
   "type": "module",
   "license": "MIT",
@@ -61,7 +61,7 @@
     "prepublishOnly": "npm run build-minified-bundle && npm run build-dev-bundle"
   },
   "dependencies": {
-    "@math.gl/core": "~5.0.0-beta.5"
+    "@math.gl/core": "~5.0.0-beta.6"
   },
-  "gitHead": "abf0b44182fb51a73368e71f1166ca1cf4de63d6"
+  "gitHead": "7a2a8a50666ead2337dac60f378dcd920587310e"
 }

package/src/index.ts

@@ -305,3 +305,7 @@ export type {PBRContactShadowProps} from './modules/lighting/pbr-contact-shadow/
 export {clusteredLightGrid} from './modules/lighting/clustered-light-grid/clustered-light-grid';
 export {pbrAmbientOcclusion} from './modules/lighting/pbr-ambient-occlusion/pbr-ambient-occlusion';
 export type {PBRAmbientOcclusionProps} from './modules/lighting/pbr-ambient-occlusion/pbr-ambient-occlusion';
+
+export {lightmapBake} from './modules/lighting/lightmap/lightmap';
+export type {LightmapBakeUniforms} from './modules/lighting/lightmap/lightmap';
+export {lightmapFilter} from './modules/lighting/lightmap/lightmap-filter';

package/src/modules/lighting/lightmap/lightmap-filter.ts

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+/** 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: {weight?: number; mode?: number}) => 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;
+}`
+} as const satisfies ShaderModule<{weight?: number; mode?: number}, {weight: number; mode: number}>;

package/src/modules/lighting/lightmap/lightmap.ts

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {NumberArray9} from '@math.gl/core';
+import type {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {pbrMaterial} from '../pbr-material/pbr-material';
+
+export type LightmapBakeUniforms = {
+  uvSet: number;
+  uvTransform: Readonly<NumberArray9>;
+  chartId: number;
+};
+
+/** 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: Partial<LightmapBakeUniforms>) => 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;
+}
+`
+} as const satisfies ShaderModule<Partial<LightmapBakeUniforms>, LightmapBakeUniforms>;

package/src/types/shader-type-decoder.ts

@@ -12,22 +12,22 @@ import {
 
 /** Information extracted from a VariableShaderType constant */
 export type VariableShaderTypeInfo = {
-  type: PrimitiveDataType;
-  components: number;
+  readonly type: PrimitiveDataType;
+  readonly components: number;
 };
 
 /** Information extracted from a AttributeShaderType constant */
 export type AttributeShaderTypeInfo = {
   /** WGSL-style primitive data type, f32, i32, u32 */
-  primitiveType: PrimitiveDataType;
+  readonly primitiveType: PrimitiveDataType;
   /** Whether this is a normalized integer (that must be used as float) */
-  components: 1 | 2 | 3 | 4;
+  readonly components: 1 | 2 | 3 | 4;
   /** Length in bytes of the data for one vertex */
-  byteLength?: number;
+  readonly byteLength?: number;
   /** Whether this is for integer or float vert */
-  integer: boolean;
+  readonly integer: boolean;
   /** Whether this data type is signed */
-  signed: boolean;
+  readonly signed: boolean;
 };
 
 /** Split a uniform type string into type and components */
@@ -42,11 +42,17 @@ export function getVariableShaderTypeInfo(
   return decoded;
 }
 
+const attributeShaderTypeInfoCache = new Map<AttributeShaderType, AttributeShaderTypeInfo>();
+
 /** Decodes a vertex type, returning byte length and flags (integer, signed, normalized) */
 export function getAttributeShaderTypeInfo(
   attributeType: AttributeShaderType | AttributeShaderTypeAlias
 ): AttributeShaderTypeInfo {
   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}`);
@@ -56,13 +62,15 @@ export function getAttributeShaderTypeInfo(
   const signed: boolean = 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;
 }
 
 export class ShaderTypeDecoder {
@@ -211,6 +219,11 @@ const UNIFORM_FORMATS: Record<VariableShaderType, {type: PrimitiveDataType; comp
   'mat4x4<u32>': {type: 'u32', components: 16}
 };
 
+// Variable metadata is already allocated in the table; freeze it once, without another cache.
+for (const info of Object.values(UNIFORM_FORMATS)) {
+  Object.freeze(info);
+}
+
 /**  Predeclared aliases @see https://www.w3.org/TR/WGSL/#vector-types */
 export const WGSL_ATTRIBUTE_TYPE_ALIAS_MAP: Record<AttributeShaderTypeAlias, AttributeShaderType> =
   {