@luma.gl/shadertools 9.1.0-alpha.16 → 9.1.0-alpha.18

package/src/index.ts

@@ -77,11 +77,17 @@ export {picking} from './modules/engine/picking/picking';
 export type {LightingProps, LightingUniforms} from './modules/lighting/lights/lighting';
 export {lighting} from './modules/lighting/lights/lighting';
 export {dirlight} from './modules/lighting/no-material/dirlight';
-export type {PhongMaterialUniforms as GouraudMaterialUniforms} from './modules/lighting/phong-material/phong-material';
+export type {GouraudMaterialProps} from './modules/lighting/gouraud-material/gouraud-material';
 export {gouraudMaterial} from './modules/lighting/gouraud-material/gouraud-material';
-export type {PhongMaterialUniforms} from './modules/lighting/phong-material/phong-material';
+export type {PhongMaterialProps} from './modules/lighting/phong-material/phong-material';
 export {phongMaterial} from './modules/lighting/phong-material/phong-material';
-// export type {PBRMaterialSettings, PBRMaterialUniforms} from './modules/lighting/pbr-material/pbr';
+export type {
+  PBRMaterialBindings,
+  PBRMaterialProps,
+  PBRMaterialUniforms
+} from './modules/lighting/pbr-material/pbr-material';
+export type {PBRProjectionProps} from './modules/lighting/pbr-material/pbr-projection';
+
 export {pbrMaterial} from './modules/lighting/pbr-material/pbr-material';
 
 // POST PROCESSING / SHADER PASS MODULES

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

@@ -2,39 +2,50 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {NumericArray} from '@math.gl/types';
-import {Sampler, Texture} from '@luma.gl/core';
-import type {UniformFormat} from '../../types';
+import {UniformFormat} from '../../types';
 import {
   PropType,
   PropValidator,
   makePropValidators,
   getValidatedProperties
 } from '../filters/prop-types';
+import type {UniformTypes, UniformValue} from '../utils/uniform-types';
 import {ShaderInjection, normalizeInjections} from '../shader-assembly/shader-injections';
 
-export type BindingValue = Buffer | Texture | Sampler;
-export type UniformValue = number | boolean | Readonly<NumericArray>;
-// Float32Array> | Readonly<Int32Array> | Readonly<Uint32Array> | Readonly<number[]>;
+// To avoid dependency on core module, do not import `Binding` type.
+// The ShaderModule is not concerned with the type of `Binding`,
+// it is the repsonsibility of `splitUniformsAndBindings` in
+// ShaderInputs to type the result of `getUniforms()`
+type Binding = unknown; // import type {Binding} from '@luma.gl/core';
 
 export type UniformInfo = {
   format?: UniformFormat;
 } & PropType;
 
+// Helper types
+type BindingKeys<T> = {[K in keyof T]: T[K] extends UniformValue ? never : K}[keyof T];
+type UniformKeys<T> = {[K in keyof T]: T[K] extends UniformValue ? K : never}[keyof T];
+export type PickBindings<T> = {[K in BindingKeys<Required<T>>]: T[K]};
+export type PickUniforms<T> = {[K in UniformKeys<Required<T>>]: T[K]};
+
 /**
  * A shader module definition object
  *
  * @note Needs to be initialized with `initializeShaderModules`
+ * @note `UniformsT` & `BindingsT` are deduced from `PropsT` by default. If
+ * a custom type for `UniformsT` is used, `BindingsT` should be also be provided.
  */
 export type ShaderModule<
-  PropsT extends Record<string, unknown> = Record<string, unknown>,
-  UniformsT extends Record<string, UniformValue> = Record<string, UniformValue>,
-  BindingsT extends Record<string, BindingValue> = Record<string, BindingValue>
+  PropsT extends Record<string, any> = Record<string, any>,
+  UniformsT extends Record<string, UniformValue> = PickUniforms<PropsT>,
+  BindingsT extends Record<string, Binding> = PickBindings<PropsT>
 > = {
   /** Used for type inference not for values */
   props?: PropsT;
   /** Used for type inference, not currently used for values */
   uniforms?: UniformsT;
+  /** Used for type inference, not currently used for values */
+  bindings?: BindingsT;
 
   name: string;
 
@@ -46,17 +57,17 @@ export type ShaderModule<
   vs?: string;
 
   /** Uniform shader types @note: Both order and types MUST match uniform block declarations in shader */
-  uniformTypes?: Record<keyof UniformsT, UniformFormat>;
+  uniformTypes?: Required<UniformTypes<UniformsT>>; // Record<keyof UniformsT, UniformFormat>;
   /** Uniform JS prop types  */
   propTypes?: Record<keyof UniformsT, UniformInfo>;
   /** Default uniform values */
   defaultUniforms?: Required<UniformsT>; // Record<keyof UniformsT, UniformValue>;
 
   /** Function that maps props to uniforms & bindings */
-  getUniforms?: (props?: any, oldProps?: any) => Record<string, BindingValue | UniformValue>;
-
-  /** uniform buffers, textures, samplers, storage, ... */
-  bindings?: Record<keyof BindingsT, {location: number; type: 'texture' | 'sampler' | 'uniforms'}>;
+  getUniforms?: (
+    props: Partial<PropsT>,
+    prevUniforms?: UniformsT
+  ) => Partial<UniformsT & BindingsT>;
 
   defines?: Record<string, string | number>;
   /** Injections */
@@ -117,9 +128,10 @@ export function initializeShaderModule(module: ShaderModule): void {
 
   module.instance = instance;
 
-  /* TODO(ib) - we need to apply the original prop types to the default uniforms
+  // TODO(ib) - we need to apply the original prop types to the default uniforms
+  let defaultProps: ShaderModule['props'] = {};
   if (propTypes) {
-    const defaultProps = Object.entries(propTypes).reduce(
+    defaultProps = Object.entries(propTypes).reduce(
       (obj: ShaderModule['props'], [key, propType]) => {
         // @ts-expect-error
         const value = propType?.value;
@@ -131,10 +143,9 @@ export function initializeShaderModule(module: ShaderModule): void {
       },
       {} as ShaderModule['props']
     );
-    const defaultUniforms = getShaderModuleUniforms(module, defaultProps);
-    module.defaultUniforms = {...module.defaultUniforms, ...defaultUniforms} as any;
   }
-  */
+
+  module.defaultUniforms = {...module.defaultUniforms, ...defaultProps} as any;
 }
 
 /** Convert module props to uniforms */
@@ -144,7 +155,7 @@ export function getShaderModuleUniforms<
   module: ShaderModuleT,
   props?: ShaderModuleT['props'],
   oldUniforms?: ShaderModuleT['uniforms']
-): Record<string, BindingValue | UniformValue> {
+): Record<string, Binding | UniformValue> {
   initializeShaderModule(module);
 
   const uniforms = oldUniforms || {...module.defaultUniforms};

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

@@ -2,7 +2,9 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {ShaderModule, UniformValue} from './shader-module';
+import type {Binding} from '@luma.gl/core';
+import type {PickBindings, PickUniforms, ShaderModule} from './shader-module';
+import type {UniformValue} from '../utils/uniform-types';
 
 /**
  * A ShaderPass is a ShaderModule that can be run "standalone" (e.g. post processing effects)
@@ -10,9 +12,10 @@ import type {ShaderModule, UniformValue} from './shader-module';
  * A ShaderPass can require one or more sub passes.
  */
 export type ShaderPass<
-  PropsT extends Record<string, unknown> = Record<string, unknown>,
-  UniformsT extends Record<string, UniformValue> = Record<string, UniformValue>
-> = ShaderModule<PropsT, UniformsT> & {
+  PropsT extends Record<string, any> = Record<string, any>,
+  UniformsT extends Record<string, UniformValue> = PickUniforms<PropsT>,
+  BindingsT extends Record<string, Binding> = PickBindings<PropsT>
+> = ShaderModule<PropsT, UniformsT, BindingsT> & {
   /** A shader pass can run multiple sub passes */
   passes?: ShaderSubPass<UniformsT>[];
   // TODO better name

package/src/lib/utils/uniform-types.ts

@@ -0,0 +1,66 @@
+import type {
+  Matrix3,
+  Matrix4,
+  Vector2,
+  Vector3,
+  Vector4,
+  NumberArray2,
+  NumberArray3,
+  NumberArray4,
+  NumberArray6,
+  NumberArray8,
+  NumberArray9,
+  NumberArray12,
+  NumberArray16
+} from '@math.gl/core';
+
+/*
+ * Allowed types to be used for uniform values
+ *
+ * Only allow types whose length we can type-check (not `TypedArray`)
+ */
+export type UniformValue = Readonly<
+  | number
+  | boolean
+  | NumberArray2
+  | NumberArray3
+  | NumberArray4
+  | NumberArray6
+  | NumberArray8
+  | NumberArray9
+  | NumberArray12
+  | NumberArray16
+  | Vector2
+  | Vector3
+  | Vector4
+  | Matrix3
+  | Matrix4
+>;
+
+type UniformType<ValueT extends UniformValue> = ValueT extends number | boolean
+  ? 'f32' | 'i32' | 'u32'
+  : ValueT extends Readonly<NumberArray2 | Vector2>
+    ? 'vec2<f32>' | 'vec2<i32>' | 'vec2<u32>'
+    : ValueT extends Readonly<NumberArray3 | Vector3>
+      ? 'vec3<f32>' | 'vec3<i32>' | 'vec3<u32>'
+      : ValueT extends Readonly<NumberArray4 | Vector4>
+        ? 'vec4<f32>' | 'vec4<i32>' | 'vec4<u32>' | 'mat2x2<f32>'
+        : ValueT extends Readonly<NumberArray6>
+          ? 'mat2x3<f32>' | 'mat3x2<f32>'
+          : ValueT extends Readonly<NumberArray8>
+            ? 'mat2x4<f32>' | 'mat4x2<f32>'
+            : ValueT extends Readonly<NumberArray9 | Matrix3>
+              ? 'mat3x3<f32>'
+              : ValueT extends Readonly<NumberArray12>
+                ? 'mat3x4<f32>' | 'mat4x3<f32>'
+                : ValueT extends Readonly<NumberArray16 | Matrix4>
+                  ? 'mat4x4<f32>'
+                  : never;
+
+type UniformProps = {
+  [name: string]: UniformValue;
+};
+
+export type UniformTypes<PropsT extends UniformProps> = {
+  [name in keyof PropsT]: UniformType<PropsT[name]>;
+};

package/src/modules/engine/picking/picking.ts

@@ -2,11 +2,11 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {NumericArray} from '../../../types';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import type {NumberArray3, NumberArray4} from '@math.gl/core';
 
 // cyan color
-const DEFAULT_HIGHLIGHT_COLOR = new Float32Array([0, 1, 1, 1]);
+const DEFAULT_HIGHLIGHT_COLOR: NumberArray4 = [0, 1, 1, 1];
 
 /**
  * Props for the picking module, which depending on mode renders picking colors or highlighted item.
@@ -19,9 +19,9 @@ export type PickingProps = {
   /** Set to true when picking an attribute value instead of object index */
   isAttribute?: boolean;
   /** Set to a picking color to visually highlight that item, or `null` to explicitly clear **/
-  highlightedObjectColor?: NumericArray | null;
+  highlightedObjectColor?: NumberArray3 | null;
   /** Color of visual highlight of "selected" item */
-  highlightColor?: NumericArray;
+  highlightColor?: NumberArray3 | NumberArray4;
   /** Color range 0-1 or 0-255 */
   useFloatColors?: boolean;
 };
@@ -44,9 +44,9 @@ export type PickingUniforms = {
   /** Do we have a highlighted item? */
   isHighlightActive?: boolean;
   /** Set to a picking color to visually highlight that item */
-  highlightedObjectColor?: NumericArray;
+  highlightedObjectColor?: NumberArray3;
   /** Color of visual highlight of "selected" item */
-  highlightColor?: NumericArray;
+  highlightColor?: NumberArray4;
 };
 
 const vs = /* glsl */ `\
@@ -208,7 +208,7 @@ export const picking = {
     isAttribute: false,
     isHighlightActive: false,
     useFloatColors: true,
-    highlightedObjectColor: new Float32Array([0, 0, 0]),
+    highlightedObjectColor: [0, 0, 0],
     highlightColor: DEFAULT_HIGHLIGHT_COLOR
   },
 
@@ -226,7 +226,7 @@ function getUniforms(opts: PickingProps = {}, prevUniforms?: PickingUniforms): P
     uniforms.isHighlightActive = false;
   } else {
     uniforms.isHighlightActive = true;
-    const highlightedObjectColor = opts.highlightedObjectColor.slice(0, 3);
+    const highlightedObjectColor = opts.highlightedObjectColor.slice(0, 3) as NumberArray3;
     uniforms.highlightedObjectColor = highlightedObjectColor;
   }
 
@@ -235,7 +235,7 @@ function getUniforms(opts: PickingProps = {}, prevUniforms?: PickingUniforms): P
     if (!Number.isFinite(color[3])) {
       color[3] = 1;
     }
-    uniforms.highlightColor = color;
+    uniforms.highlightColor = color as NumberArray4;
   }
 
   if (opts.isActive !== undefined) {

package/src/modules/engine/project/project.ts

@@ -2,19 +2,20 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {NumericArray as NumberArray, Matrix4, Vector3} from '@math.gl/core';
+import {Matrix4, Vector3} from '@math.gl/core';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
+import type {NumberArray3, NumberArray16} from '@math.gl/core';
 
-const IDENTITY_MATRIX: Readonly<NumberArray> = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+const IDENTITY_MATRIX: Readonly<NumberArray16> = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 
 /**
  * @note Projection uniforms are normally constant across draw calls,
  * at least for each view.
  */
 export type ProjectionProps = {
-  viewMatrix?: Readonly<Matrix4 | NumberArray>;
-  projectionMatrix?: Readonly<Matrix4 | NumberArray>;
-  cameraPositionWorld?: Readonly<Vector3 | NumberArray>;
+  viewMatrix?: Readonly<Matrix4 | NumberArray16>;
+  projectionMatrix?: Readonly<Matrix4 | NumberArray16>;
+  cameraPositionWorld?: Readonly<Vector3 | NumberArray3>;
 };
 
 /**
@@ -22,10 +23,10 @@ export type ProjectionProps = {
  * at least for each view.
  */
 export type ProjectionUniforms = {
-  viewMatrix?: Readonly<Matrix4 | NumberArray>;
-  projectionMatrix?: Readonly<Matrix4 | NumberArray>;
-  viewProjectionMatrix?: Readonly<Matrix4 | NumberArray>;
-  cameraPositionWorld?: Readonly<Vector3 | NumberArray>;
+  viewMatrix?: Readonly<Matrix4 | NumberArray16>;
+  projectionMatrix?: Readonly<Matrix4 | NumberArray16>;
+  viewProjectionMatrix?: Readonly<Matrix4 | NumberArray16>;
+  cameraPositionWorld?: Readonly<Vector3 | NumberArray3>;
 };
 
 const DEFAULT_MODULE_OPTIONS: Required<ProjectionUniforms> = {

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

@@ -2,13 +2,12 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import {NumberArray3} from '@math.gl/types';
 import {ShaderModule} from '../../../lib/shader-module/shader-module';
 import {lighting} from '../lights/lighting';
-import {GOURAUD_VS, GOURAUD_FS} from './gouraud-shaders-glsl';
+import {PHONG_VS, PHONG_FS} from '../phong-material/phong-shaders-glsl';
 
-export type GouraudMaterialProps = GouraudMaterialUniforms;
-
-export type GouraudMaterialUniforms = {
+export type GouraudMaterialProps = {
   ambient?: number;
   diffuse?: number;
   /** Specularity exponent */
@@ -17,14 +16,13 @@ export type GouraudMaterialUniforms = {
 };
 
 /** In Gouraud shading, color is calculated for each triangle vertex normal, and then color is interpolated colors across the triangle */
-export const gouraudMaterial = {
+export const gouraudMaterial: ShaderModule<GouraudMaterialProps> = {
   props: {} as GouraudMaterialProps,
-  uniforms: {} as GouraudMaterialUniforms,
 
-  name: 'gouraud-lighting',
+  name: 'gouraudMaterial',
   // Note these are switched between phong and gouraud
-  vs: GOURAUD_VS,
-  fs: GOURAUD_FS,
+  vs: PHONG_FS.replace('phongMaterial', 'gouraudMaterial'),
+  fs: PHONG_VS.replace('phongMaterial', 'gouraudMaterial'),
   defines: {
     LIGHTING_VERTEX: 1
   },
@@ -42,7 +40,11 @@ export const gouraudMaterial = {
     specularColor: [0.15, 0.15, 0.15]
   },
 
-  getUniforms(props: GouraudMaterialProps): GouraudMaterialUniforms {
-    return {...gouraudMaterial.defaultUniforms, ...props};
+  getUniforms(props: GouraudMaterialProps) {
+    const uniforms = {...props};
+    if (uniforms.specularColor) {
+      uniforms.specularColor = uniforms.specularColor.map(x => x / 255) as NumberArray3;
+    }
+    return {...gouraudMaterial.defaultUniforms, ...uniforms};
   }
-} as const satisfies ShaderModule<GouraudMaterialProps, GouraudMaterialUniforms>;
+};

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

@@ -23,28 +23,51 @@ struct DirectionalLight {
 
 uniform lightingUniforms {
   int enabled;
-  int pointLightCount;
+  int lightType;
+
   int directionalLightCount;
+  int pointLightCount;
 
   vec3 ambientColor;
 
-  int lightType;
-  vec3 lightColor;
-  vec3 lightDirection;
-  vec3 lightPosition;
-  vec3 lightAttenuation;
-
-  // AmbientLight ambientLight;
-  // PointLight pointLight[MAX_LIGHTS];
-  // DirectionalLight directionalLight[MAX_LIGHTS];
+  vec3 lightColor0;
+  vec3 lightPosition0;
+  vec3 lightDirection0;
+  vec3 lightAttenuation0;
+
+  vec3 lightColor1;
+  vec3 lightPosition1;
+  vec3 lightDirection1;
+  vec3 lightAttenuation1;
+
+  vec3 lightColor2;
+  vec3 lightPosition2;
+  vec3 lightDirection2;
+  vec3 lightAttenuation2;
 } lighting;
 
 PointLight lighting_getPointLight(int index) {
-  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:
+    default:  
+      return PointLight(lighting.lightColor2, lighting.lightPosition2, lighting.lightAttenuation2);
+  }
 }
 
 DirectionalLight lighting_getDirectionalLight(int index) {
-  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:
+    default:   
+      return DirectionalLight(lighting.lightColor2, lighting.lightDirection2);
+  }
 } 
 
 float getPointLightAttenuation(PointLight pointLight, float distance) {