@luma.gl/shadertools 9.2.6 → 9.3.0-alpha.11

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

@@ -0,0 +1,114 @@
+// 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}>,
+};
+
+@group(0) @binding(auto) 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 */ `\
+
+layout(std140) 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',
+  bindingLayout: [{name: 'skin', group: 0}],
+  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>', SKIN_MAX_JOINTS]
+  }
+} as const satisfies ShaderModule<SkinProps, SkinUniforms>;

package/src/modules/lighting/gouraud-material/gouraud-material.ts

@@ -9,6 +9,7 @@ import {PHONG_VS, PHONG_FS} from '../phong-material/phong-shaders-glsl';
 import {PHONG_WGSL} from '../phong-material/phong-shaders-wgsl';
 
 export type GouraudMaterialProps = {
+  unlit?: boolean;
   ambient?: number;
   diffuse?: number;
   /** Specularity exponent */
@@ -21,6 +22,7 @@ export const gouraudMaterial: ShaderModule<GouraudMaterialProps> = {
   props: {} as GouraudMaterialProps,
 
   name: 'gouraudMaterial',
+  bindingLayout: [{name: 'gouraudMaterial', group: 3}],
   // Note these are switched between phong and gouraud
   vs: PHONG_FS.replace('phongMaterial', 'gouraudMaterial'),
   fs: PHONG_VS.replace('phongMaterial', 'gouraudMaterial'),
@@ -30,12 +32,14 @@ export const gouraudMaterial: ShaderModule<GouraudMaterialProps> = {
   },
   dependencies: [lighting],
   uniformTypes: {
+    unlit: 'i32',
     ambient: 'f32',
     diffuse: 'f32',
     shininess: 'f32',
     specularColor: 'vec3<f32>'
   },
   defaultUniforms: {
+    unlit: false,
     ambient: 0.35,
     diffuse: 0.6,
     shininess: 32,

package/src/modules/lighting/ibl/ibl.ts

@@ -0,0 +1,44 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Texture} from '@luma.gl/core';
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+export type IBLBindings = {
+  pbr_diffuseEnvSampler?: Texture | null;
+  pbr_specularEnvSampler?: Texture | null;
+  pbr_brdfLUT?: Texture | null;
+};
+
+export const iblWGSL = /* wgsl */ `\
+#ifdef USE_IBL
+@group(2) @binding(auto) var pbr_diffuseEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_diffuseEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_specularEnvSampler: texture_cube<f32>;
+@group(2) @binding(auto) var pbr_specularEnvSamplerSampler: sampler;
+@group(2) @binding(auto) var pbr_brdfLUT: texture_2d<f32>;
+@group(2) @binding(auto) var pbr_brdfLUTSampler: sampler;
+#endif
+`;
+
+export const iblGLSL = /* glsl */ `\
+#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
+`;
+
+export const ibl = {
+  name: 'ibl',
+  firstBindingSlot: 32,
+  bindingLayout: [
+    {name: 'pbr_diffuseEnvSampler', group: 2},
+    {name: 'pbr_specularEnvSampler', group: 2},
+    {name: 'pbr_brdfLUT', group: 2}
+  ],
+  source: iblWGSL,
+  vs: iblGLSL,
+  fs: iblGLSL
+} as const satisfies ShaderModule<IBLBindings, {}, IBLBindings>;

package/src/modules/lighting/lambert-material/lambert-material.ts

@@ -0,0 +1,42 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {lighting} from '../lights/lighting';
+import {LAMBERT_WGSL} from './lambert-shaders-wgsl';
+import {LAMBERT_VS, LAMBERT_FS} from './lambert-shaders-glsl';
+
+/** Uniform props for the built-in diffuse-only Lambert material model. */
+export type LambertMaterialProps = {
+  unlit?: boolean;
+  ambient?: number;
+  diffuse?: number;
+};
+
+/** A matte material model that applies diffuse-only Lambert lighting per fragment. */
+export const lambertMaterial: ShaderModule<LambertMaterialProps> = {
+  name: 'lambertMaterial',
+  firstBindingSlot: 0,
+  bindingLayout: [{name: 'lambertMaterial', group: 3}],
+  dependencies: [lighting],
+  source: LAMBERT_WGSL,
+  vs: LAMBERT_VS,
+  fs: LAMBERT_FS,
+  defines: {
+    LIGHTING_FRAGMENT: true
+  },
+  uniformTypes: {
+    unlit: 'i32',
+    ambient: 'f32',
+    diffuse: 'f32'
+  },
+  defaultUniforms: {
+    unlit: false,
+    ambient: 0.35,
+    diffuse: 0.6
+  },
+  getUniforms(props?: LambertMaterialProps) {
+    return {...lambertMaterial.defaultUniforms, ...props};
+  }
+};

package/src/modules/lighting/lambert-material/lambert-shaders-glsl.ts

@@ -0,0 +1,61 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export const LAMBERT_VS = /* glsl */ `\
+layout(std140) uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+`;
+
+export const LAMBERT_FS = /* glsl */ `\
+layout(std140) uniform lambertMaterialUniforms {
+  uniform bool unlit;
+  uniform float ambient;
+  uniform float diffuse;
+} material;
+
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 light_direction, vec3 normal_worldspace, vec3 color) {
+  float lambertian = max(dot(light_direction, normal_worldspace), 0.0);
+  return lambertian * material.diffuse * surfaceColor * color;
+}
+
+vec3 lighting_getLightColor(vec3 surfaceColor, vec3 cameraPosition, vec3 position_worldspace, vec3 normal_worldspace) {
+  vec3 lightColor = surfaceColor;
+
+  if (material.unlit) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  lightColor = material.ambient * surfaceColor * lighting.ambientColor;
+
+  for (int i = 0; i < lighting.pointLightCount; i++) {
+    PointLight pointLight = lighting_getPointLight(i);
+    vec3 light_position_worldspace = pointLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getPointLightAttenuation(pointLight, distance(light_position_worldspace, position_worldspace));
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, normal_worldspace, pointLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.spotLightCount; i++) {
+    SpotLight spotLight = lighting_getSpotLight(i);
+    vec3 light_position_worldspace = spotLight.position;
+    vec3 light_direction = normalize(light_position_worldspace - position_worldspace);
+    float light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(surfaceColor, light_direction, normal_worldspace, spotLight.color / light_attenuation);
+  }
+
+  for (int i = 0; i < lighting.directionalLightCount; i++) {
+    DirectionalLight directionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(surfaceColor, -directionalLight.direction, normal_worldspace, directionalLight.color);
+  }
+
+  return lightColor;
+}
+`;

package/src/modules/lighting/lambert-material/lambert-shaders-wgsl.ts

@@ -0,0 +1,73 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export const LAMBERT_WGSL = /* wgsl */ `\
+struct lambertMaterialUniforms {
+  unlit: u32,
+  ambient: f32,
+  diffuse: f32,
+};
+
+@group(3) @binding(auto) var<uniform> lambertMaterial : lambertMaterialUniforms;
+
+fn lighting_getLightColor(surfaceColor: vec3<f32>, light_direction: vec3<f32>, normal_worldspace: vec3<f32>, color: vec3<f32>) -> vec3<f32> {
+  let lambertian: f32 = max(dot(light_direction, normal_worldspace), 0.0);
+  return lambertian * lambertMaterial.diffuse * surfaceColor * color;
+}
+
+fn lighting_getLightColor2(surfaceColor: vec3<f32>, cameraPosition: vec3<f32>, position_worldspace: vec3<f32>, normal_worldspace: vec3<f32>) -> vec3<f32> {
+  var lightColor: vec3<f32> = surfaceColor;
+
+  if (lambertMaterial.unlit != 0u) {
+    return surfaceColor;
+  }
+
+  if (lighting.enabled == 0) {
+    return lightColor;
+  }
+
+  lightColor = lambertMaterial.ambient * surfaceColor * lighting.ambientColor;
+
+  for (var i: i32 = 0; i < lighting.pointLightCount; i++) {
+    let pointLight: PointLight = lighting_getPointLight(i);
+    let light_position_worldspace: vec3<f32> = pointLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getPointLightAttenuation(
+      pointLight,
+      distance(light_position_worldspace, position_worldspace)
+    );
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      normal_worldspace,
+      pointLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.spotLightCount; i++) {
+    let spotLight: SpotLight = lighting_getSpotLight(i);
+    let light_position_worldspace: vec3<f32> = spotLight.position;
+    let light_direction: vec3<f32> = normalize(light_position_worldspace - position_worldspace);
+    let light_attenuation = getSpotLightAttenuation(spotLight, position_worldspace);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      light_direction,
+      normal_worldspace,
+      spotLight.color / light_attenuation
+    );
+  }
+
+  for (var i: i32 = 0; i < lighting.directionalLightCount; i++) {
+    let directionalLight: DirectionalLight = lighting_getDirectionalLight(i);
+    lightColor += lighting_getLightColor(
+      surfaceColor,
+      -directionalLight.direction,
+      normal_worldspace,
+      directionalLight.color
+    );
+  }
+
+  return lightColor;
+}
+`;

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

@@ -16,59 +16,51 @@ struct PointLight {
   vec3 attenuation; // 2nd order x:Constant-y:Linear-z:Exponential
 };
 
+struct SpotLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
+
 struct DirectionalLight {
   vec3 color;
   vec3 direction;
 };
 
-uniform lightingUniforms {
-  int enabled;
-  int lightType;
+struct UniformLight {
+  vec3 color;
+  vec3 position;
+  vec3 direction;
+  vec3 attenuation;
+  vec2 coneCos;
+};
 
+layout(std140) uniform lightingUniforms {
+  int enabled;
   int directionalLightCount;
   int pointLightCount;
-
+  int spotLightCount;
   vec3 ambientColor;
-
-  vec3 lightColor0;
-  vec3 lightPosition0;
-  vec3 lightDirection0;
-  vec3 lightAttenuation0;
-
-  vec3 lightColor1;
-  vec3 lightPosition1;
-  vec3 lightDirection1;
-  vec3 lightAttenuation1;
-
-  vec3 lightColor2;
-  vec3 lightPosition2;
-  vec3 lightDirection2;
-  vec3 lightAttenuation2;
+  UniformLight lights[5];
 } lighting;
 
 PointLight lighting_getPointLight(int index) {
-  switch (index) {
-    case 0:
-      return PointLight(lighting.lightColor0, lighting.lightPosition0, lighting.lightAttenuation0);
-    case 1:
-      return PointLight(lighting.lightColor1, lighting.lightPosition1, lighting.lightAttenuation1);
-    case 2:
-    default:  
-      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
-  }
+  UniformLight light = lighting.lights[index];
+  return PointLight(light.color, light.position, light.attenuation);
+}
+
+SpotLight lighting_getSpotLight(int index) {
+  UniformLight light = lighting.lights[lighting.pointLightCount + index];
+  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);
 }
 
 DirectionalLight lighting_getDirectionalLight(int index) {
-  switch (index) {
-    case 0:
-      return DirectionalLight(lighting.lightColor0, lighting.lightDirection0);
-    case 1:
-      return DirectionalLight(lighting.lightColor1, lighting.lightDirection1);
-    case 2:
-    default:   
-      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
-  }
-} 
+  UniformLight light =
+    lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];
+  return DirectionalLight(light.color, light.direction);
+}
 
 float getPointLightAttenuation(PointLight pointLight, float distance) {
   return pointLight.attenuation.x
@@ -76,5 +68,19 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
        + pointLight.attenuation.z * distance * distance;
 }
 
+float getSpotLightAttenuation(SpotLight spotLight, vec3 positionWorldspace) {
+  vec3 light_direction = normalize(positionWorldspace - spotLight.position);
+  float coneFactor = smoothstep(
+    spotLight.coneCos.y,
+    spotLight.coneCos.x,
+    dot(normalize(spotLight.direction), light_direction)
+  );
+  float distanceAttenuation = getPointLightAttenuation(
+    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),
+    distance(spotLight.position, positionWorldspace)
+  );
+  return distanceAttenuation / max(coneFactor, 0.0001);
+}
+
 // #endif
 `;

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>,
 };
@@ -14,44 +16,70 @@ struct PointLight {
   attenuation: vec3<f32>, // 2nd order x:Constant-y:Linear-z:Exponential
 };
 
+struct SpotLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  direction: vec3<f32>,
+  attenuation: vec3<f32>,
+  coneCos: vec2<f32>,
+};
+
 struct DirectionalLight {
   color: vec3<f32>,
   direction: vec3<f32>,
 };
 
+struct UniformLight {
+  color: vec3<f32>,
+  position: vec3<f32>,
+  direction: vec3<f32>,
+  attenuation: vec3<f32>,
+  coneCos: vec2<f32>,
+};
+
 struct lightingUniforms {
   enabled: i32,
-  pointLightCount: i32,
   directionalLightCount: i32,
-
+  pointLightCount: i32,
+  spotLightCount: 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];
+  lights: array<UniformLight, 5>,
 };
 
-// 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;
+@group(2) @binding(auto) var<uniform> lighting : lightingUniforms;
 
 fn lighting_getPointLight(index: i32) -> PointLight {
-  return PointLight(lighting.lightColor, lighting.lightPosition, lighting.lightAttenuation);
+  let light = lighting.lights[index];
+  return PointLight(light.color, light.position, light.attenuation);
+}
+
+fn lighting_getSpotLight(index: i32) -> SpotLight {
+  let light = lighting.lights[lighting.pointLightCount + index];
+  return SpotLight(light.color, light.position, light.direction, light.attenuation, light.coneCos);
 }
 
 fn lighting_getDirectionalLight(index: i32) -> DirectionalLight {
-  return DirectionalLight(lighting.lightColor, lighting.lightDirection);
-} 
+  let light = lighting.lights[lighting.pointLightCount + lighting.spotLightCount + index];
+  return DirectionalLight(light.color, light.direction);
+}
 
 fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
   return pointLight.attenuation.x
        + pointLight.attenuation.y * distance
        + pointLight.attenuation.z * distance * distance;
 }
+
+fn getSpotLightAttenuation(spotLight: SpotLight, positionWorldspace: vec3<f32>) -> f32 {
+  let lightDirection = normalize(positionWorldspace - spotLight.position);
+  let coneFactor = smoothstep(
+    spotLight.coneCos.y,
+    spotLight.coneCos.x,
+    dot(normalize(spotLight.direction), lightDirection)
+  );
+  let distanceAttenuation = getPointLightAttenuation(
+    PointLight(spotLight.color, spotLight.position, spotLight.attenuation),
+    distance(spotLight.position, positionWorldspace)
+  );
+  return distanceAttenuation / max(coneFactor, 0.0001);
+}
 `;