@luma.gl/shadertools 9.3.0-alpha.2 → 9.3.0-alpha.6

package/src/lib/shader-module/shader-module.ts

@@ -71,7 +71,7 @@ export type ShaderModule<
     prevUniforms?: UniformsT
   ) => Partial<UniformsT & BindingsT>;
 
-  defines?: Record<string, boolean>;
+  defines?: Record<string, boolean | number>;
   /** Injections */
   inject?: Record<string, string | {injection: string; order: number}>;
   dependencies?: ShaderModule<any, any>[];

package/src/lib/utils/assert.ts

@@ -6,6 +6,8 @@
 // message so keep it for now.
 export function assert(condition: unknown, message?: string): void {
   if (!condition) {
-    throw new Error(message || 'shadertools: assertion failed.');
+    const error = new Error(message || 'shadertools: assertion failed.');
+    Error.captureStackTrace?.(error, assert);
+    throw error;
   }
 }

package/src/modules/engine/skin/skin.ts

@@ -0,0 +1,116 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Matrix4} from '@math.gl/core';
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+const SKIN_MAX_JOINTS = 20;
+
+export const source = /* wgsl */ `
+struct skinUniforms {
+  jointMatrix: array<mat4x4<f32>, ${SKIN_MAX_JOINTS}>,
+};
+
+@binding(19) @group(0) var<uniform> skin: skinUniforms;
+
+fn getSkinMatrix(weights: vec4f, joints: vec4u) -> mat4x4<f32> {
+  return (weights.x * skin.jointMatrix[joints.x])
+       + (weights.y * skin.jointMatrix[joints.y])
+       + (weights.z * skin.jointMatrix[joints.z])
+       + (weights.w * skin.jointMatrix[joints.w]);
+}
+`;
+
+export const vs = /* glsl */ `\
+
+uniform skinUniforms {
+  mat4 jointMatrix[SKIN_MAX_JOINTS];
+} skin;
+
+mat4 getSkinMatrix(vec4 weights, uvec4 joints) {
+  return (weights.x * skin.jointMatrix[joints.x])
+       + (weights.y * skin.jointMatrix[joints.y])
+       + (weights.z * skin.jointMatrix[joints.z])
+       + (weights.w * skin.jointMatrix[joints.w]);
+}
+
+`;
+
+export const fs = /* glsl */ `\
+`;
+
+export type SkinProps = {
+  scenegraphsFromGLTF?: any;
+};
+
+export type SkinUniforms = {
+  jointMatrix?: any;
+};
+
+export const skin = {
+  props: {} as SkinProps,
+  uniforms: {} as SkinUniforms,
+
+  name: 'skin',
+  dependencies: [],
+  source,
+  vs,
+  fs,
+
+  defines: {
+    SKIN_MAX_JOINTS
+  },
+
+  getUniforms: (props: SkinProps = {}, prevUniforms?: SkinUniforms): SkinUniforms => {
+    const {scenegraphsFromGLTF} = props;
+
+    if (!scenegraphsFromGLTF?.gltf?.skins?.[0]) {
+      return {jointMatrix: []};
+    }
+
+    const {inverseBindMatrices, joints, skeleton} = scenegraphsFromGLTF.gltf.skins[0];
+
+    const matsib = [];
+    const countib = inverseBindMatrices.value.length / 16;
+    for (let i = 0; i < countib; i++) {
+      const slice = inverseBindMatrices.value.subarray(i * 16, i * 16 + 16);
+      matsib.push(new Matrix4(Array.from(slice)));
+    }
+
+    const top = scenegraphsFromGLTF.gltfNodeIndexToNodeMap.get(skeleton);
+    const matrices: Record<string, Matrix4> = {};
+    top.preorderTraversal((node: any, {worldMatrix}: any) => {
+      matrices[node.id] = worldMatrix;
+    });
+
+    const mats = new Float32Array(SKIN_MAX_JOINTS * 16); // 16 floats per 4x4 matrix
+    for (let i = 0; i < SKIN_MAX_JOINTS; ++i) {
+      const nodeIndex = joints[i];
+      if (nodeIndex === undefined) break;
+
+      const worldMat = matrices[scenegraphsFromGLTF.gltfNodeIndexToNodeMap.get(nodeIndex).id];
+      const invBindMat = matsib[i];
+
+      const Z = new Matrix4().copy(worldMat).multiplyRight(invBindMat);
+
+      const off = i * 16;
+
+      for (let j = 0; j < 16; j++) {
+        mats[off + j] = Z[j];
+      }
+    }
+
+    return {
+      jointMatrix: mats
+    };
+  },
+
+  uniformTypes: {
+    jointMatrix: 'mat4x4<f32>'
+  },
+  uniformSizes: {
+    jointMatrix: SKIN_MAX_JOINTS
+  }
+} as const satisfies ShaderModule<SkinProps, SkinUniforms>;

package/src/modules/lighting/lights/lighting-glsl.ts

@@ -44,6 +44,16 @@ uniform lightingUniforms {
   vec3 lightPosition2;
   vec3 lightDirection2;
   vec3 lightAttenuation2;
+
+  vec3 lightColor3;
+  vec3 lightPosition3;
+  vec3 lightDirection3;
+  vec3 lightAttenuation3;
+
+  vec3 lightColor4;
+  vec3 lightPosition4;
+  vec3 lightDirection4;
+  vec3 lightAttenuation4;
 } lighting;
 
 PointLight lighting_getPointLight(int index) {
@@ -53,8 +63,12 @@ PointLight lighting_getPointLight(int index) {
     case 1:
       return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
     case 2:
-    default:  
       return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
+    case 3:
+      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);
+    case 4:
+    default:  
+      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);
   }
 }
 
@@ -65,8 +79,12 @@ DirectionalLight lighting_getDirectionalLight(int index) {
     case 1:
       return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
     case 2:
-    default:   
       return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
+    case 3:
+      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);
+    case 4:
+    default:   
+      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);
   }
 } 
 

package/src/modules/lighting/lights/lighting-wgsl.ts

@@ -4,6 +4,8 @@
 
 export const lightingUniformsWGSL = /* wgsl */ `\
 // #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
+const MAX_LIGHTS: i32 = 5;
+
 struct AmbientLight {
   color: vec3<f32>,
 };
@@ -21,32 +23,80 @@ struct DirectionalLight {
 
 struct lightingUniforms {
   enabled: i32,
-  pointLightCount: i32,
+  lightType: i32,
+
   directionalLightCount: i32,
+  pointLightCount: i32,
 
   ambientColor: vec3<f32>,
 
-  // TODO - support multiple lights by uncommenting arrays below
-  lightType: i32,
-  lightColor: vec3<f32>,
-  lightDirection: vec3<f32>,
-  lightPosition: vec3<f32>,
-  lightAttenuation: vec3<f32>,
-
-  // AmbientLight ambientLight;
-  // PointLight pointLight[MAX_LIGHTS];
-  // DirectionalLight directionalLight[MAX_LIGHTS];
+  lightColor0: vec3<f32>,
+  lightPosition0: vec3<f32>,
+  lightDirection0: vec3<f32>,
+  lightAttenuation0: vec3<f32>,
+
+  lightColor1: vec3<f32>,
+  lightPosition1: vec3<f32>,
+  lightDirection1: vec3<f32>,
+  lightAttenuation1: vec3<f32>,
+
+  lightColor2: vec3<f32>,
+  lightPosition2: vec3<f32>,
+  lightDirection2: vec3<f32>,
+  lightAttenuation2: vec3<f32>,
+
+  lightColor3: vec3<f32>,
+  lightPosition3: vec3<f32>,
+  lightDirection3: vec3<f32>,
+  lightAttenuation3: vec3<f32>,
+
+  lightColor4: vec3<f32>,
+  lightPosition4: vec3<f32>,
+  lightDirection4: vec3<f32>,
+  lightAttenuation4: vec3<f32>,
 };
 
 // Binding 0:1 is reserved for lighting (Note: could go into separate bind group as it is stable across draw calls)
 @binding(1) @group(0) var<uniform> lighting : lightingUniforms;
 
 fn lighting_getPointLight(index: i32) -> PointLight {
-  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
+  switch (index) {
+    case 0: {
+      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);
+    }
+    case 1: {
+      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
+    }
+    case 2: {
+      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
+    }
+    case 3: {
+      return PointLight(lighting.lightColor3, lighting.lightPosition3, lighting.lightAttenuation3);
+    }
+    case 4, default: {
+      return PointLight(lighting.lightColor4, lighting.lightPosition4, lighting.lightAttenuation4);
+    }
+  }
 }
 
 fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
-  return DirectionalLight(lighting.lightColor, lighting.lightDirection);
+  switch (index) {
+    case 0: {
+      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);
+    }
+    case 1: {
+      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
+    }
+    case 2: {
+      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
+    }
+    case 3: {
+      return DirectionalLight(lighting.lightColor3, lighting.lightDirection3);
+    }
+    case 4, default: {
+      return DirectionalLight(lighting.lightColor4, lighting.lightDirection4);
+    }
+  }
 } 
 
 fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {

package/src/modules/lighting/lights/lighting.ts

@@ -75,6 +75,14 @@ export type LightingUniforms = {
   lightPosition2: Readonly<NumberArray3>;
   lightDirection2: Readonly<NumberArray3>;
   lightAttenuation2: Readonly<NumberArray3>;
+  lightColor3: Readonly<NumberArray3>;
+  lightPosition3: Readonly<NumberArray3>;
+  lightDirection3: Readonly<NumberArray3>;
+  lightAttenuation3: Readonly<NumberArray3>;
+  lightColor4: Readonly<NumberArray3>;
+  lightPosition4: Readonly<NumberArray3>;
+  lightDirection4: Readonly<NumberArray3>;
+  lightAttenuation4: Readonly<NumberArray3>;
 };
 
 /** UBO ready lighting module */
@@ -111,7 +119,17 @@ export const lighting = {
     lightColor2: 'vec3<f32>',
     lightPosition2: 'vec3<f32>',
     lightDirection2: 'vec3<f32>',
-    lightAttenuation2: 'vec3<f32>'
+    lightAttenuation2: 'vec3<f32>',
+
+    lightColor3: 'vec3<f32>',
+    lightPosition3: 'vec3<f32>',
+    lightDirection3: 'vec3<f32>',
+    lightAttenuation3: 'vec3<f32>',
+
+    lightColor4: 'vec3<f32>',
+    lightPosition4: 'vec3<f32>',
+    lightDirection4: 'vec3<f32>',
+    lightAttenuation4: 'vec3<f32>'
   },
 
   defaultUniforms: {
@@ -135,7 +153,15 @@ export const lighting = {
     lightColor2: [1, 1, 1],
     lightPosition2: [1, 1, 2],
     lightDirection2: [1, 1, 1],
-    lightAttenuation2: [1, 0, 0]
+    lightAttenuation2: [1, 0, 0],
+    lightColor3: [1, 1, 1],
+    lightPosition3: [1, 1, 2],
+    lightDirection3: [1, 1, 1],
+    lightAttenuation3: [1, 0, 0],
+    lightColor4: [1, 1, 1],
+    lightPosition4: [1, 1, 2],
+    lightDirection4: [1, 1, 1],
+    lightAttenuation4: [1, 0, 0]
   },
   source: lightingUniformsWGSL,
   vs: lightingUniformsGLSL,
@@ -194,33 +220,43 @@ function getLightSourceUniforms({
 
   lightSourceUniforms.ambientColor = convertColor(ambientLight);
 
-  let currentLight: 0 | 1 | 2 = 0;
+  let currentLight = 0;
+  let pointLightCount = 0;
+  let directionalLightCount = 0;
 
   for (const pointLight of pointLights) {
+    if (currentLight >= MAX_LIGHTS) {
+      break;
+    }
     lightSourceUniforms.lightType = LIGHT_TYPE.POINT;
 
-    const i = currentLight as 0 | 1 | 2;
+    const i = currentLight as 0 | 1 | 2 | 3 | 4;
     lightSourceUniforms[`lightColor${i}`] = convertColor(pointLight);
     lightSourceUniforms[`lightPosition${i}`] = pointLight.position;
     lightSourceUniforms[`lightAttenuation${i}`] = pointLight.attenuation || [1, 0, 0];
     currentLight++;
+    pointLightCount++;
   }
 
   for (const directionalLight of directionalLights) {
+    if (currentLight >= MAX_LIGHTS) {
+      break;
+    }
     lightSourceUniforms.lightType = LIGHT_TYPE.DIRECTIONAL;
 
-    const i = currentLight as 0 | 1 | 2;
+    const i = currentLight as 0 | 1 | 2 | 3 | 4;
     lightSourceUniforms[`lightColor${i}`] = convertColor(directionalLight);
     lightSourceUniforms[`lightDirection${i}`] = directionalLight.direction;
     currentLight++;
+    directionalLightCount++;
   }
 
-  if (currentLight > MAX_LIGHTS) {
-    log.warn('MAX_LIGHTS exceeded')();
+  if (pointLights.length + directionalLights.length > MAX_LIGHTS) {
+    log.warn(`MAX_LIGHTS exceeded, truncating to ${MAX_LIGHTS}`)();
   }
 
-  lightSourceUniforms.directionalLightCount = directionalLights.length;
-  lightSourceUniforms.pointLightCount = pointLights.length;
+  lightSourceUniforms.directionalLightCount = directionalLightCount;
+  lightSourceUniforms.pointLightCount = pointLightCount;
 
   return lightSourceUniforms;
 }