@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.6

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

@@ -0,0 +1,517 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/* eslint-disable camelcase */
+
+import type {
+  Matrix3,
+  NumberArray2,
+  NumberArray3,
+  NumberArray4,
+  NumberArray9,
+  Vector2,
+  Vector3,
+  Vector4
+} from '@math.gl/core';
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import {ibl} from '../ibl/ibl';
+import {lighting} from '../lights/lighting';
+import {areaLighting} from '../area-lighting/area-lighting';
+
+import {fs, vs} from './pbr-material-glsl';
+import {source} from './pbr-material-wgsl';
+import {pbrProjection} from './pbr-projection';
+import {pbrScene} from './pbr-scene';
+
+/** Non-uniform block bindings for pbr module */
+export type PBRMaterialBindings<TextureT = unknown> = {
+  // Samplers
+  pbr_baseColorSampler?: TextureT | null; // #ifdef HAS_BASECOLORMAP
+  pbr_normalSampler?: TextureT | null; // #ifdef HAS_NORMALMAP
+  pbr_emissiveSampler?: TextureT | null; // #ifdef HAS_EMISSIVEMAP
+  pbr_lightmapSampler?: TextureT | null; // #ifdef HAS_LIGHTMAP
+  pbr_metallicRoughnessSampler?: TextureT | null; // #ifdef HAS_METALROUGHNESSMAP
+  pbr_occlusionSampler?: TextureT | null; // #ifdef HAS_OCCLUSIONMAP
+
+  pbr_specularColorSampler?: TextureT | null; // #ifdef HAS_SPECULARCOLORMAP
+  pbr_specularIntensitySampler?: TextureT | null; // #ifdef HAS_SPECULARINTENSITYMAP
+  pbr_transmissionSampler?: TextureT | null; // #ifdef HAS_TRANSMISSIONMAP
+  pbr_thicknessSampler?: TextureT | null; // #ifdef HAS_THICKNESSMAP
+
+  pbr_clearcoatSampler?: TextureT | null; // #ifdef HAS_CLEARCOATMAP
+  pbr_clearcoatRoughnessSampler?: TextureT | null; // #ifdef HAS_CLEARCOATROUGHNESSMAP
+  pbr_clearcoatNormalSampler?: TextureT | null; // #ifdef HAS_CLEARCOATNORMALMAP
+  pbr_sheenColorSampler?: TextureT | null; // #ifdef HAS_SHEENCOLORMAP
+  pbr_sheenRoughnessSampler?: TextureT | null; // #ifdef HAS_SHEENROUGHNESSMAP
+  pbr_iridescenceSampler?: TextureT | null; // #ifdef HAS_IRIDESCENCEMAP
+  pbr_iridescenceThicknessSampler?: TextureT | null; // #ifdef HAS_IRIDESCENCETHICKNESSMAP
+  pbr_anisotropySampler?: TextureT | null; // #ifdef HAS_ANISOTROPYMAP
+  pbr_bumpSampler?: TextureT | null; // #ifdef HAS_BUMPMAP
+  pbr_diffuseTransmissionSampler?: TextureT | null; // #ifdef HAS_DIFFUSETRANSMISSIONMAP
+  pbr_diffuseTransmissionColorSampler?: TextureT | null; // #ifdef HAS_DIFFUSETRANSMISSIONCOLORMAP
+  pbr_multiscatterColorSampler?: TextureT | null; // #ifdef HAS_MULTISCATTERCOLORMAP
+};
+
+export type PBRMaterialUniforms = {
+  unlit?: boolean;
+
+  // Base color map
+  baseColorMapEnabled?: boolean;
+  baseColorFactor?: Readonly<Vector4 | NumberArray4>;
+
+  normalMapEnabled?: boolean;
+  normalScale?: number; // #ifdef HAS_NORMALMAP
+
+  emissiveMapEnabled?: boolean;
+  lightmapMapEnabled?: boolean;
+  emissiveFactor?: Readonly<Vector3 | NumberArray3>; // #ifdef HAS_EMISSIVEMAP
+
+  metallicRoughnessValues?: Readonly<Vector2 | NumberArray2>;
+  metallicRoughnessMapEnabled?: boolean;
+
+  occlusionMapEnabled?: boolean;
+  occlusionStrength?: number; // #ifdef HAS_OCCLUSIONMAP
+
+  alphaCutoffEnabled?: boolean;
+  alphaCutoff?: number; // #ifdef ALPHA_CUTOFF
+
+  // IBL
+  IBLenabled?: boolean;
+  scaleIBLAmbient?: Readonly<Vector2 | NumberArray2>; // #ifdef USE_IBL
+
+  // debugging flags used for shader output of intermediate PBR variables
+  // #ifdef PBR_DEBUG
+  scaleDiffBaseMR?: Readonly<Vector4 | NumberArray4>;
+  scaleFGDSpec?: Readonly<Vector4 | NumberArray4>;
+
+  // glTF material extensions
+  specularColorFactor?: Readonly<Vector3 | NumberArray3>;
+  specularIntensityFactor?: number;
+  specularColorMapEnabled?: boolean;
+  specularIntensityMapEnabled?: boolean;
+
+  ior?: number;
+
+  /** Chromatic transmission spread, expressed as 20 divided by the material Abbe number. */
+  dispersion?: number;
+
+  transmissionFactor?: number;
+  transmissionMapEnabled?: boolean;
+
+  thicknessFactor?: number;
+  attenuationDistance?: number;
+  attenuationColor?: Readonly<Vector3 | NumberArray3>;
+
+  clearcoatFactor?: number;
+  clearcoatRoughnessFactor?: number;
+  clearcoatMapEnabled?: boolean;
+  clearcoatRoughnessMapEnabled?: boolean;
+
+  sheenColorFactor?: Readonly<Vector3 | NumberArray3>;
+  sheenRoughnessFactor?: number;
+  sheenColorMapEnabled?: boolean;
+  sheenRoughnessMapEnabled?: boolean;
+
+  iridescenceFactor?: number;
+  iridescenceIor?: number;
+  iridescenceThicknessRange?: Readonly<Vector2 | NumberArray2>;
+  iridescenceMapEnabled?: boolean;
+
+  anisotropyStrength?: number;
+  anisotropyRotation?: number;
+  anisotropyDirection?: Readonly<Vector2 | NumberArray2>;
+  anisotropyMapEnabled?: boolean;
+
+  emissiveStrength?: number;
+  lightmapIntensity?: number;
+  scatterStrengthFactor?: number;
+
+  baseColorUVSet?: number;
+  baseColorUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  metallicRoughnessUVSet?: number;
+  metallicRoughnessUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  normalUVSet?: number;
+  normalUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  occlusionUVSet?: number;
+  occlusionUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  emissiveUVSet?: number;
+  lightmapUVSet?: number;
+  emissiveUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  lightmapUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  specularColorUVSet?: number;
+  specularColorUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  specularIntensityUVSet?: number;
+  specularIntensityUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  transmissionUVSet?: number;
+  transmissionUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  thicknessUVSet?: number;
+  thicknessUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  clearcoatUVSet?: number;
+  clearcoatUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  clearcoatRoughnessUVSet?: number;
+  clearcoatRoughnessUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  clearcoatNormalUVSet?: number;
+  clearcoatNormalUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  sheenColorUVSet?: number;
+  sheenColorUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  sheenRoughnessUVSet?: number;
+  sheenRoughnessUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  iridescenceUVSet?: number;
+  iridescenceUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  iridescenceThicknessUVSet?: number;
+  iridescenceThicknessUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  anisotropyUVSet?: number;
+  anisotropyUVTransform?: Readonly<NumberArray9 | Matrix3>;
+
+  /** Surface-height scale for the draft EXT_materials_bump extension. */
+  bumpFactor?: number;
+  bumpMapEnabled?: boolean;
+  /** Fraction of dielectric diffuse energy transmitted into the opposite hemisphere. */
+  diffuseTransmissionFactor?: number;
+  diffuseTransmissionMapEnabled?: boolean;
+  diffuseTransmissionColorFactor?: Readonly<Vector3 | NumberArray3>;
+  diffuseTransmissionColorMapEnabled?: boolean;
+  /** Experimental multi-scatter albedo from the unratified volume-scattering draft. */
+  multiscatterColorFactor?: Readonly<Vector3 | NumberArray3>;
+  multiscatterColorMapEnabled?: boolean;
+  /** Henyey-Greenstein scattering anisotropy, ranging from -1 to 1. */
+  scatterAnisotropy?: number;
+
+  bumpUVSet?: number;
+  bumpUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  diffuseTransmissionUVSet?: number;
+  diffuseTransmissionUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  diffuseTransmissionColorUVSet?: number;
+  diffuseTransmissionColorUVTransform?: Readonly<NumberArray9 | Matrix3>;
+  multiscatterColorUVSet?: number;
+  multiscatterColorUVTransform?: Readonly<NumberArray9 | Matrix3>;
+};
+
+export type PBRMaterialProps<TextureT = unknown> = PBRMaterialBindings<TextureT> &
+  PBRMaterialUniforms;
+
+/**
+ * An implementation of PBR (Physically-Based Rendering).
+ * Physically Based Shading of a microfacet surface defined by a glTF material.
+ */
+export const pbrMaterial = {
+  props: {} as PBRMaterialProps,
+  uniforms: {} as PBRMaterialUniforms,
+  defaultUniforms: {
+    unlit: false,
+
+    baseColorMapEnabled: false,
+    baseColorFactor: [1, 1, 1, 1],
+
+    normalMapEnabled: false,
+    normalScale: 1,
+
+    emissiveMapEnabled: false,
+    lightmapMapEnabled: false,
+    emissiveFactor: [0, 0, 0],
+
+    metallicRoughnessValues: [1, 1],
+    metallicRoughnessMapEnabled: false,
+
+    occlusionMapEnabled: false,
+    occlusionStrength: 1,
+
+    alphaCutoffEnabled: false,
+    alphaCutoff: 0.5,
+
+    IBLenabled: false,
+    scaleIBLAmbient: [1, 1],
+
+    scaleDiffBaseMR: [0, 0, 0, 0],
+    scaleFGDSpec: [0, 0, 0, 0],
+
+    specularColorFactor: [1, 1, 1],
+    specularIntensityFactor: 1,
+    specularColorMapEnabled: false,
+    specularIntensityMapEnabled: false,
+
+    ior: 1.5,
+
+    transmissionFactor: 0,
+    transmissionMapEnabled: false,
+
+    thicknessFactor: 0,
+    attenuationDistance: 1e9,
+    attenuationColor: [1, 1, 1],
+
+    clearcoatFactor: 0,
+    clearcoatRoughnessFactor: 0,
+    clearcoatMapEnabled: false,
+    clearcoatRoughnessMapEnabled: false,
+
+    sheenColorFactor: [0, 0, 0],
+    sheenRoughnessFactor: 0,
+    sheenColorMapEnabled: false,
+    sheenRoughnessMapEnabled: false,
+
+    iridescenceFactor: 0,
+    iridescenceIor: 1.3,
+    iridescenceThicknessRange: [100, 400],
+    iridescenceMapEnabled: false,
+
+    anisotropyStrength: 0,
+    anisotropyRotation: 0,
+    anisotropyDirection: [1, 0],
+    anisotropyMapEnabled: false,
+
+    emissiveStrength: 1,
+    lightmapIntensity: 1,
+    scatterStrengthFactor: 0,
+    dispersion: 0,
+
+    baseColorUVSet: 0,
+    baseColorUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    metallicRoughnessUVSet: 0,
+    metallicRoughnessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    normalUVSet: 0,
+    normalUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    occlusionUVSet: 0,
+    occlusionUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    emissiveUVSet: 0,
+    lightmapUVSet: 0,
+    emissiveUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    lightmapUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    specularColorUVSet: 0,
+    specularColorUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    specularIntensityUVSet: 0,
+    specularIntensityUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    transmissionUVSet: 0,
+    transmissionUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    thicknessUVSet: 0,
+    thicknessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    clearcoatUVSet: 0,
+    clearcoatUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    clearcoatRoughnessUVSet: 0,
+    clearcoatRoughnessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    clearcoatNormalUVSet: 0,
+    clearcoatNormalUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    sheenColorUVSet: 0,
+    sheenColorUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    sheenRoughnessUVSet: 0,
+    sheenRoughnessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    iridescenceUVSet: 0,
+    iridescenceUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    iridescenceThicknessUVSet: 0,
+    iridescenceThicknessUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    anisotropyUVSet: 0,
+    anisotropyUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+
+    bumpFactor: 1,
+    bumpMapEnabled: false,
+    diffuseTransmissionFactor: 0,
+    diffuseTransmissionMapEnabled: false,
+    diffuseTransmissionColorFactor: [1, 1, 1],
+    diffuseTransmissionColorMapEnabled: false,
+    multiscatterColorFactor: [0, 0, 0],
+    multiscatterColorMapEnabled: false,
+    scatterAnisotropy: 0,
+
+    bumpUVSet: 0,
+    bumpUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    diffuseTransmissionUVSet: 0,
+    diffuseTransmissionUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    diffuseTransmissionColorUVSet: 0,
+    diffuseTransmissionColorUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1],
+    multiscatterColorUVSet: 0,
+    multiscatterColorUVTransform: [1, 0, 0, 0, 1, 0, 0, 0, 1]
+  } as Required<PBRMaterialUniforms>,
+
+  name: 'pbrMaterial',
+  firstBindingSlot: 0,
+  bindingLayout: [
+    {name: 'pbrMaterial', group: 3},
+    {name: 'pbr_baseColorSampler', group: 3},
+    {name: 'pbr_normalSampler', group: 3},
+    {name: 'pbr_emissiveSampler', group: 3},
+    {name: 'pbr_lightmapSampler', group: 3},
+    {name: 'pbr_metallicRoughnessSampler', group: 3},
+    {name: 'pbr_occlusionSampler', group: 3},
+    {name: 'pbr_specularColorSampler', group: 3},
+    {name: 'pbr_specularIntensitySampler', group: 3},
+    {name: 'pbr_transmissionSampler', group: 3},
+    {name: 'pbr_thicknessSampler', group: 3},
+    {name: 'pbr_clearcoatSampler', group: 3},
+    {name: 'pbr_clearcoatRoughnessSampler', group: 3},
+    {name: 'pbr_clearcoatNormalSampler', group: 3},
+    {name: 'pbr_sheenColorSampler', group: 3},
+    {name: 'pbr_sheenRoughnessSampler', group: 3},
+    {name: 'pbr_iridescenceSampler', group: 3},
+    {name: 'pbr_iridescenceThicknessSampler', group: 3},
+    {name: 'pbr_anisotropySampler', group: 3},
+    {name: 'pbr_bumpSampler', group: 3},
+    {name: 'pbr_diffuseTransmissionSampler', group: 3},
+    {name: 'pbr_diffuseTransmissionColorSampler', group: 3},
+    {name: 'pbr_multiscatterColorSampler', group: 3}
+  ],
+  // GLSL requires scene uniforms to be declared before the material functions that use them.
+  dependencies: [lighting, areaLighting, ibl, pbrProjection, pbrScene],
+  source,
+  vs,
+  fs,
+
+  defines: {
+    LIGHTING_FRAGMENT: true,
+    HAS_NORMALMAP: false,
+    HAS_EMISSIVEMAP: false,
+    HAS_LIGHTMAP: false,
+    HAS_OCCLUSIONMAP: false,
+    HAS_BASECOLORMAP: false,
+    HAS_METALROUGHNESSMAP: false,
+    HAS_SPECULARCOLORMAP: false,
+    HAS_SPECULARINTENSITYMAP: false,
+    HAS_TRANSMISSIONMAP: false,
+    HAS_THICKNESSMAP: false,
+    HAS_CLEARCOATMAP: false,
+    HAS_CLEARCOATROUGHNESSMAP: false,
+    HAS_CLEARCOATNORMALMAP: false,
+    HAS_SHEENCOLORMAP: false,
+    HAS_SHEENROUGHNESSMAP: false,
+    HAS_IRIDESCENCEMAP: false,
+    HAS_IRIDESCENCETHICKNESSMAP: false,
+    HAS_ANISOTROPYMAP: false,
+    HAS_BUMPMAP: false,
+    HAS_DIFFUSETRANSMISSIONMAP: false,
+    HAS_DIFFUSETRANSMISSIONCOLORMAP: false,
+    HAS_MULTISCATTERCOLORMAP: false,
+    USE_MATERIAL_EXTENSIONS: false,
+    ALPHA_CUTOFF: false,
+    USE_IBL: false,
+    PBR_DEBUG: false
+  },
+  getUniforms: props => props,
+  uniformTypes: {
+    // Material is unlit
+    unlit: 'i32',
+
+    // Base color map
+    baseColorMapEnabled: 'i32',
+    baseColorFactor: 'vec4<f32>',
+
+    normalMapEnabled: 'i32',
+    normalScale: 'f32', // #ifdef HAS_NORMALMAP
+
+    emissiveMapEnabled: 'i32',
+    emissiveFactor: 'vec3<f32>', // #ifdef HAS_EMISSIVEMAP
+
+    metallicRoughnessValues: 'vec2<f32>',
+    metallicRoughnessMapEnabled: 'i32',
+
+    occlusionMapEnabled: 'i32',
+    occlusionStrength: 'f32', // #ifdef HAS_OCCLUSIONMAP
+
+    alphaCutoffEnabled: 'i32',
+    alphaCutoff: 'f32', // #ifdef ALPHA_CUTOFF
+
+    specularColorFactor: 'vec3<f32>',
+    specularIntensityFactor: 'f32',
+    specularColorMapEnabled: 'i32',
+    specularIntensityMapEnabled: 'i32',
+
+    ior: 'f32',
+
+    transmissionFactor: 'f32',
+    transmissionMapEnabled: 'i32',
+
+    thicknessFactor: 'f32',
+    attenuationDistance: 'f32',
+    attenuationColor: 'vec3<f32>',
+
+    clearcoatFactor: 'f32',
+    clearcoatRoughnessFactor: 'f32',
+    clearcoatMapEnabled: 'i32',
+    clearcoatRoughnessMapEnabled: 'i32',
+
+    sheenColorFactor: 'vec3<f32>',
+    sheenRoughnessFactor: 'f32',
+    sheenColorMapEnabled: 'i32',
+    sheenRoughnessMapEnabled: 'i32',
+
+    iridescenceFactor: 'f32',
+    iridescenceIor: 'f32',
+    iridescenceThicknessRange: 'vec2<f32>',
+    iridescenceMapEnabled: 'i32',
+
+    anisotropyStrength: 'f32',
+    anisotropyRotation: 'f32',
+    anisotropyDirection: 'vec2<f32>',
+    anisotropyMapEnabled: 'i32',
+
+    emissiveStrength: 'f32',
+    dispersion: 'f32',
+
+    // IBL
+    IBLenabled: 'i32',
+    scaleIBLAmbient: 'vec2<f32>', // #ifdef USE_IBL
+
+    // debugging flags used for shader output of intermediate PBR variables
+    // #ifdef PBR_DEBUG
+    scaleDiffBaseMR: 'vec4<f32>',
+    scaleFGDSpec: 'vec4<f32>',
+
+    baseColorUVSet: 'i32',
+    baseColorUVTransform: 'mat3x3<f32>',
+    metallicRoughnessUVSet: 'i32',
+    metallicRoughnessUVTransform: 'mat3x3<f32>',
+    normalUVSet: 'i32',
+    normalUVTransform: 'mat3x3<f32>',
+    occlusionUVSet: 'i32',
+    occlusionUVTransform: 'mat3x3<f32>',
+    emissiveUVSet: 'i32',
+    emissiveUVTransform: 'mat3x3<f32>',
+    specularColorUVSet: 'i32',
+    specularColorUVTransform: 'mat3x3<f32>',
+    specularIntensityUVSet: 'i32',
+    specularIntensityUVTransform: 'mat3x3<f32>',
+    transmissionUVSet: 'i32',
+    transmissionUVTransform: 'mat3x3<f32>',
+    thicknessUVSet: 'i32',
+    thicknessUVTransform: 'mat3x3<f32>',
+    clearcoatUVSet: 'i32',
+    clearcoatUVTransform: 'mat3x3<f32>',
+    clearcoatRoughnessUVSet: 'i32',
+    clearcoatRoughnessUVTransform: 'mat3x3<f32>',
+    clearcoatNormalUVSet: 'i32',
+    clearcoatNormalUVTransform: 'mat3x3<f32>',
+    sheenColorUVSet: 'i32',
+    sheenColorUVTransform: 'mat3x3<f32>',
+    sheenRoughnessUVSet: 'i32',
+    sheenRoughnessUVTransform: 'mat3x3<f32>',
+    iridescenceUVSet: 'i32',
+    iridescenceUVTransform: 'mat3x3<f32>',
+    iridescenceThicknessUVSet: 'i32',
+    iridescenceThicknessUVTransform: 'mat3x3<f32>',
+    anisotropyUVSet: 'i32',
+    anisotropyUVTransform: 'mat3x3<f32>',
+
+    bumpFactor: 'f32',
+    bumpMapEnabled: 'i32',
+    diffuseTransmissionFactor: 'f32',
+    diffuseTransmissionMapEnabled: 'i32',
+    diffuseTransmissionColorFactor: 'vec3<f32>',
+    diffuseTransmissionColorMapEnabled: 'i32',
+    multiscatterColorFactor: 'vec3<f32>',
+    multiscatterColorMapEnabled: 'i32',
+    scatterAnisotropy: 'f32',
+
+    bumpUVSet: 'i32',
+    bumpUVTransform: 'mat3x3<f32>',
+    diffuseTransmissionUVSet: 'i32',
+    diffuseTransmissionUVTransform: 'mat3x3<f32>',
+    diffuseTransmissionColorUVSet: 'i32',
+    diffuseTransmissionColorUVTransform: 'mat3x3<f32>',
+    multiscatterColorUVSet: 'i32',
+    multiscatterColorUVTransform: 'mat3x3<f32>',
+    lightmapMapEnabled: 'i32',
+    lightmapIntensity: 'f32',
+    lightmapUVSet: 'i32',
+    lightmapUVTransform: 'mat3x3<f32>',
+    scatterStrengthFactor: 'f32'
+  }
+} as const satisfies ShaderModule<PBRMaterialProps, PBRMaterialUniforms, PBRMaterialBindings>;

package/src/modules/lighting/pbr-material/pbr-projection.ts

@@ -0,0 +1,50 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {NumberArray3, NumberArray16} from '@math.gl/core';
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+const uniformBlock = /* glsl */ `\
+layout(std140) uniform pbrProjectionUniforms {
+  mat4 modelViewProjectionMatrix;
+  mat4 modelMatrix;
+  mat4 normalMatrix;
+  vec3 camera;
+} pbrProjection;
+`;
+
+const wgslUniformBlock = /* wgsl */ `\
+struct pbrProjectionUniforms {
+  modelViewProjectionMatrix: mat4x4<f32>,
+  modelMatrix: mat4x4<f32>,
+  normalMatrix: mat4x4<f32>,
+  camera: vec3<f32>
+};
+
+@group(0) @binding(auto) var<uniform> pbrProjection: pbrProjectionUniforms;
+`;
+
+export type PBRProjectionProps = {
+  modelViewProjectionMatrix: NumberArray16;
+  modelMatrix: NumberArray16;
+  normalMatrix: NumberArray16;
+  camera: NumberArray3;
+};
+
+export const pbrProjection: ShaderModule<PBRProjectionProps> = {
+  name: 'pbrProjection',
+  bindingLayout: [{name: 'pbrProjection', group: 0}],
+  source: wgslUniformBlock,
+  vs: uniformBlock,
+  fs: uniformBlock,
+  // TODO why is this needed?
+  getUniforms: props => props,
+  uniformTypes: {
+    modelViewProjectionMatrix: 'mat4x4<f32>',
+    modelMatrix: 'mat4x4<f32>',
+    normalMatrix: 'mat4x4<f32>',
+    camera: 'vec3<f32>'
+  }
+};

package/src/modules/lighting/pbr-material/pbr-scene.ts

@@ -0,0 +1,112 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {NumberArray2, NumberArray16} from '@math.gl/core';
+
+import {ShaderModule} from '../../../lib/shader-module/shader-module';
+
+/** Portable scene tone-mapping modes shared by the GLSL and WGSL PBR implementations. */
+export const PBR_TONE_MAP_MODE = {
+  NONE: 0,
+  REINHARD: 1,
+  KHRONOS_PBR_NEUTRAL: 2,
+  ACES: 3
+} as const;
+
+export type PBRToneMapMode = (typeof PBR_TONE_MAP_MODE)[keyof typeof PBR_TONE_MAP_MODE];
+
+export type PBRSceneBindings<TextureT = unknown> = {
+  pbr_transmissionFramebufferSampler?: TextureT | null;
+};
+
+export type PBRSceneUniforms = {
+  exposure?: number;
+  toneMapMode?: number;
+  environmentIntensity?: number;
+  environmentRotation?: number;
+  environmentMipCount?: number;
+  /** Zero keeps scene radiance linear; one applies the exact sRGB output transfer function. */
+  outputEncoding?: number;
+  framebufferSize?: NumberArray2;
+  viewMatrix?: NumberArray16;
+  projectionMatrix?: NumberArray16;
+};
+
+export type PBRSceneProps<TextureT = unknown> = PBRSceneBindings<TextureT> & PBRSceneUniforms;
+
+const IDENTITY_MATRIX: NumberArray16 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+
+// Match integer precision across stages without relying on a preceding lighting module.
+const uniformBlock = /* glsl */ `\
+layout(std140) uniform pbrSceneUniforms {
+  float exposure;
+  highp int toneMapMode;
+  float environmentIntensity;
+  float environmentRotation;
+  float environmentMipCount;
+  highp int outputEncoding;
+  vec2 framebufferSize;
+  mat4 viewMatrix;
+  mat4 projectionMatrix;
+} pbrScene;
+
+#ifdef USE_TRANSMISSION_FRAMEBUFFER
+uniform sampler2D pbr_transmissionFramebufferSampler;
+#endif
+`;
+
+const wgslUniformBlock = /* wgsl */ `\
+struct pbrSceneUniforms {
+  exposure: f32,
+  toneMapMode: i32,
+  environmentIntensity: f32,
+  environmentRotation: f32,
+  environmentMipCount: f32,
+  outputEncoding: i32,
+  framebufferSize: vec2<f32>,
+  viewMatrix: mat4x4<f32>,
+  projectionMatrix: mat4x4<f32>
+};
+
+@group(1) @binding(auto) var<uniform> pbrScene: pbrSceneUniforms;
+
+#ifdef USE_TRANSMISSION_FRAMEBUFFER
+@group(1) @binding(auto) var pbr_transmissionFramebufferSampler: texture_2d<f32>;
+@group(1) @binding(auto) var pbr_transmissionFramebufferSamplerSampler: sampler;
+#endif
+`;
+
+export const pbrScene = {
+  name: 'pbrScene',
+  bindingLayout: [
+    {name: 'pbrScene', group: 1},
+    {name: 'pbr_transmissionFramebufferSampler', group: 1}
+  ],
+  source: wgslUniformBlock,
+  vs: uniformBlock,
+  fs: uniformBlock,
+  getUniforms: (props: PBRSceneProps) => props,
+  uniformTypes: {
+    exposure: 'f32',
+    toneMapMode: 'i32',
+    environmentIntensity: 'f32',
+    environmentRotation: 'f32',
+    environmentMipCount: 'f32',
+    outputEncoding: 'i32',
+    framebufferSize: 'vec2<f32>',
+    viewMatrix: 'mat4x4<f32>',
+    projectionMatrix: 'mat4x4<f32>'
+  },
+  defaultUniforms: {
+    exposure: 1,
+    toneMapMode: PBR_TONE_MAP_MODE.KHRONOS_PBR_NEUTRAL,
+    environmentIntensity: 1,
+    environmentRotation: Math.PI * 0.5,
+    environmentMipCount: 1,
+    outputEncoding: 1,
+    framebufferSize: [1, 1],
+    viewMatrix: IDENTITY_MATRIX,
+    projectionMatrix: IDENTITY_MATRIX
+  } as Required<PBRSceneUniforms>
+} as const satisfies ShaderModule<PBRSceneProps, PBRSceneUniforms, PBRSceneBindings>;