@luma.gl/engine 9.3.0-alpha.4 → 9.3.0-alpha.8

package/src/scenegraph/model-node.ts

@@ -9,12 +9,12 @@ import {Model} from '../model/model';
 export type ModelNodeProps = ScenegraphNodeProps & {
   model: Model;
   managedResources?: any[];
-  bounds?: [number[], number[]];
+  bounds?: [[number, number, number], [number, number, number]];
 };
 
 export class ModelNode extends ScenegraphNode {
   readonly model: Model;
-  bounds: [number[], number[]] | null = null;
+  bounds: [[number, number, number], [number, number, number]] | null = null;
   managedResources: any[];
 
   // TODO - is this used? override callbacks to make sure we call them with this

package/src/scenegraph/scenegraph-node.ts

@@ -5,6 +5,12 @@
 import {Vector3, Matrix4, NumericArray} from '@math.gl/core';
 import {uid} from '../utils/uid';
 
+function assert(condition: boolean, message?: string): asserts condition {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
 /** Properties for creating a new Scenegraph */
 export type ScenegraphNodeProps = {
   id?: string;
@@ -57,19 +63,19 @@ export class ScenegraphNode {
   }
 
   setPosition(position: any): this {
-    // assert(position.length === 3, 'setPosition requires vector argument');
+    assert(position.length === 3, 'setPosition requires vector argument');
     this.position = position;
     return this;
   }
 
   setRotation(rotation: any): this {
-    // assert(rotation.length === 3, 'setRotation requires vector argument');
+    assert(rotation.length === 3 || rotation.length === 4, 'setRotation requires vector argument');
     this.rotation = rotation;
     return this;
   }
 
   setScale(scale: any): this {
-    // assert(scale.length === 3, 'setScale requires vector argument');
+    assert(scale.length === 3, 'setScale requires vector argument');
     this.scale = scale;
     return this;
   }
@@ -105,19 +111,20 @@ export class ScenegraphNode {
   }
 
   updateMatrix(): this {
-    const pos = this.position;
-    const rot = this.rotation;
-    const scale = this.scale;
-
     this.matrix.identity();
-    this.matrix.translate(pos);
-    this.matrix.rotateXYZ(rot);
-    this.matrix.scale(scale);
+    this.matrix.translate(this.position);
+    if (this.rotation.length === 4) {
+      const rotationMatrix = new Matrix4().fromQuaternion(this.rotation);
+      this.matrix.multiplyRight(rotationMatrix);
+    } else {
+      this.matrix.rotateXYZ(this.rotation);
+    }
+    this.matrix.scale(this.scale);
+
     return this;
   }
 
-  update(options: {position?: any; rotation?: any; scale?: any} = {}): this {
-    const {position, rotation, scale} = options;
+  update({position, rotation, scale}: {position?: any; rotation?: any; scale?: any} = {}): this {
     if (position) {
       this.setPosition(position);
     }
@@ -127,7 +134,9 @@ export class ScenegraphNode {
     if (scale) {
       this.setScale(scale);
     }
+
     this.updateMatrix();
+
     return this;
   }
 
@@ -188,18 +197,20 @@ export class ScenegraphNode {
     //   this.display = props.display;
     // }
 
-    if ('position' in props) {
+    if (props?.position) {
       this.setPosition(props.position);
     }
-    if ('rotation' in props) {
+    if (props?.rotation) {
       this.setRotation(props.rotation);
     }
-    if ('scale' in props) {
+    if (props?.scale) {
       this.setScale(props.scale);
     }
 
+    this.updateMatrix();
+
     // Matrix overwrites other props
-    if ('matrix' in props) {
+    if (props?.matrix) {
       this.setMatrix(props.matrix);
     }
 

package/src/shader-inputs.ts

@@ -2,16 +2,25 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Binding, UniformValue} from '@luma.gl/core';
+import type {Binding, CompositeShaderType} from '@luma.gl/core';
 import {log} from '@luma.gl/core';
 // import type {VariableShaderType, UniformValue, UniformFormat, UniformInfoDevice, Texture, Sampler} from '@luma.gl/core';
-import {getShaderModuleDependencies, ShaderModule} from '@luma.gl/shadertools';
+import {
+  getShaderModuleDependencies,
+  ShaderModule,
+  ShaderModuleUniformValue
+} from '@luma.gl/shadertools';
 import {splitUniformsAndBindings} from './model/split-uniforms-and-bindings';
 
 export type ShaderInputsOptions = {
   disableWarnings?: boolean;
 };
 
+type ShaderInputsModule = Pick<
+  ShaderModule<any, any, any>,
+  'bindingLayout' | 'defaultUniforms' | 'dependencies' | 'getUniforms' | 'name' | 'uniformTypes'
+>;
+
 /**
  * ShaderInputs holds uniform and binding values for one or more shader modules,
  * - It can generate binary data for any uniform buffer
@@ -33,10 +42,10 @@ export class ShaderInputs<
    * @todo should should this include the resolved dependencies?
    */
   // @ts-ignore Fix typings
-  modules: Readonly<{[P in keyof ShaderPropsT]: ShaderModule<ShaderPropsT[P]>}>;
+  modules: Readonly<{[P in keyof ShaderPropsT]: ShaderInputsModule}>;
 
   /** Stores the uniform values for each module */
-  moduleUniforms: Record<keyof ShaderPropsT, Record<string, UniformValue>>;
+  moduleUniforms: Record<keyof ShaderPropsT, Record<string, ShaderModuleUniformValue>>;
   /** Stores the uniform bindings for each module  */
   moduleBindings: Record<keyof ShaderPropsT, Record<string, Binding>>;
   /** Tracks if uniforms have changed */
@@ -48,14 +57,14 @@ export class ShaderInputs<
    */
   constructor(
     // @ts-ignore Fix typings
-    modules: {[P in keyof ShaderPropsT]?: ShaderModule<ShaderPropsT[P], any>},
+    modules: {[P in keyof ShaderPropsT]?: ShaderInputsModule},
     options?: ShaderInputsOptions
   ) {
     Object.assign(this.options, options);
 
     // Extract modules with dependencies
     const resolvedModules = getShaderModuleDependencies(
-      Object.values(modules).filter(module => module.dependencies)
+      Object.values(modules).filter(isShaderInputsModuleWithDependencies)
     );
     for (const resolvedModule of resolvedModules) {
       // @ts-ignore
@@ -66,12 +75,19 @@ export class ShaderInputs<
 
     // Store the module definitions and create storage for uniform values and binding values, per module
     // @ts-ignore Fix typings
-    this.modules = modules as {[P in keyof ShaderPropsT]: ShaderModule<ShaderPropsT[P]>};
-    this.moduleUniforms = {} as Record<keyof ShaderPropsT, Record<string, UniformValue>>;
+    this.modules = modules as {[P in keyof ShaderPropsT]: ShaderInputsModule};
+    this.moduleUniforms = {} as Record<
+      keyof ShaderPropsT,
+      Record<string, ShaderModuleUniformValue>
+    >;
     this.moduleBindings = {} as Record<keyof ShaderPropsT, Record<string, Binding>>;
 
     // Initialize the modules
     for (const [name, module] of Object.entries(modules)) {
+      if (!module) {
+        continue;
+      }
+
       this._addModule(module);
       if (module.name && name !== module.name && !this.options.disableWarnings) {
         log.warn(`Module name: ${name} vs ${module.name}`)();
@@ -98,13 +114,20 @@ export class ShaderInputs<
         continue; // eslint-disable-line no-continue
       }
 
-      const oldUniforms = this.moduleUniforms[moduleName] as (typeof module)['uniforms'];
+      const oldUniforms = this.moduleUniforms[moduleName];
       const oldBindings = this.moduleBindings[moduleName];
       const uniformsAndBindings =
         module.getUniforms?.(moduleProps, oldUniforms) || (moduleProps as any);
 
-      const {uniforms, bindings} = splitUniformsAndBindings(uniformsAndBindings);
-      this.moduleUniforms[moduleName] = {...oldUniforms, ...uniforms};
+      const {uniforms, bindings} = splitUniformsAndBindings(
+        uniformsAndBindings,
+        module.uniformTypes as Readonly<Record<string, CompositeShaderType>>
+      );
+      this.moduleUniforms[moduleName] = mergeModuleUniforms(
+        oldUniforms as Record<string, ShaderModuleUniformValue>,
+        uniforms,
+        module.uniformTypes as Readonly<Record<string, CompositeShaderType>>
+      );
       this.moduleBindings[moduleName] = {...oldBindings, ...bindings};
       // this.moduleUniformsChanged ||= moduleName;
 
@@ -117,11 +140,13 @@ export class ShaderInputs<
    * @todo should should this include the resolved dependencies?
    */
   getModules(): ShaderModule[] {
-    return Object.values(this.modules);
+    return Object.values(this.modules) as ShaderModule[];
   }
 
   /** Get all uniform values for all modules */
-  getUniformValues(): Partial<Record<keyof ShaderPropsT, Record<string, UniformValue>>> {
+  getUniformValues(): Partial<
+    Record<keyof ShaderPropsT, Record<string, ShaderModuleUniformValue>>
+  > {
     return this.moduleUniforms;
   }
 
@@ -150,10 +175,135 @@ export class ShaderInputs<
     return table;
   }
 
-  _addModule(module: ShaderModule): void {
+  _addModule(module: ShaderInputsModule): void {
     const moduleName = module.name as keyof ShaderPropsT;
     // Get default uniforms from module
-    this.moduleUniforms[moduleName] = module.defaultUniforms || {};
+    this.moduleUniforms[moduleName] = mergeModuleUniforms(
+      {},
+      (module.defaultUniforms || {}) as Record<string, ShaderModuleUniformValue>,
+      module.uniformTypes as Readonly<Record<string, CompositeShaderType>>
+    );
     this.moduleBindings[moduleName] = {};
   }
 }
+
+function mergeModuleUniforms(
+  currentUniforms: Record<string, ShaderModuleUniformValue> = {},
+  nextUniforms: Record<string, ShaderModuleUniformValue> = {},
+  uniformTypes: Readonly<Record<string, CompositeShaderType>> = {}
+): Record<string, ShaderModuleUniformValue> {
+  const mergedUniforms = {...currentUniforms};
+  for (const [key, value] of Object.entries(nextUniforms)) {
+    if (value === undefined) {
+      continue;
+    }
+
+    mergedUniforms[key] = mergeModuleUniformValue(currentUniforms[key], value, uniformTypes[key]);
+  }
+  return mergedUniforms;
+}
+
+function mergeModuleUniformValue(
+  currentValue: ShaderModuleUniformValue | undefined,
+  nextValue: ShaderModuleUniformValue,
+  uniformType: CompositeShaderType | undefined
+): ShaderModuleUniformValue {
+  if (!uniformType || typeof uniformType === 'string') {
+    return cloneModuleUniformValue(nextValue);
+  }
+
+  if (Array.isArray(uniformType)) {
+    if (isPackedUniformArrayValue(nextValue) || !Array.isArray(nextValue)) {
+      return cloneModuleUniformValue(nextValue);
+    }
+
+    const currentArray: Array<ShaderModuleUniformValue | undefined> =
+      Array.isArray(currentValue) && !isPackedUniformArrayValue(currentValue)
+        ? [...currentValue]
+        : [];
+    const mergedArray = currentArray.slice();
+    for (let index = 0; index < nextValue.length; index++) {
+      const elementValue = nextValue[index];
+      if (elementValue === undefined) {
+        continue;
+      }
+
+      mergedArray[index] = mergeModuleUniformValue(
+        currentArray[index],
+        elementValue,
+        uniformType[0] as CompositeShaderType
+      );
+    }
+    return mergedArray;
+  }
+
+  if (!isPlainUniformObject(nextValue)) {
+    return cloneModuleUniformValue(nextValue);
+  }
+
+  const uniformStruct = uniformType as Record<string, CompositeShaderType>;
+  const currentObject = isPlainUniformObject(currentValue) ? currentValue : {};
+  const mergedObject: Record<string, ShaderModuleUniformValue | undefined> = {...currentObject};
+  for (const [key, value] of Object.entries(nextValue)) {
+    if (value === undefined) {
+      continue;
+    }
+
+    mergedObject[key] = mergeModuleUniformValue(currentObject[key], value, uniformStruct[key]);
+  }
+  return mergedObject as ShaderModuleUniformValue;
+}
+
+function cloneModuleUniformValue(value: ShaderModuleUniformValue): ShaderModuleUniformValue {
+  if (ArrayBuffer.isView(value)) {
+    return Array.prototype.slice.call(value) as ShaderModuleUniformValue;
+  }
+
+  if (Array.isArray(value)) {
+    if (isPackedUniformArrayValue(value)) {
+      return value.slice() as ShaderModuleUniformValue;
+    }
+
+    const compositeArray = value as ReadonlyArray<ShaderModuleUniformValue | undefined>;
+    return compositeArray.map(element =>
+      element === undefined ? undefined : cloneModuleUniformValue(element)
+    ) as ShaderModuleUniformValue;
+  }
+
+  if (isPlainUniformObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nestedValue]) => [
+        key,
+        nestedValue === undefined ? undefined : cloneModuleUniformValue(nestedValue)
+      ])
+    ) as ShaderModuleUniformValue;
+  }
+
+  return value;
+}
+
+function isPackedUniformArrayValue(
+  value: unknown
+): value is ReadonlyArray<number> | ArrayBufferView {
+  return (
+    ArrayBuffer.isView(value) ||
+    (Array.isArray(value) && (value.length === 0 || typeof value[0] === 'number'))
+  );
+}
+
+function isPlainUniformObject(
+  value: unknown
+): value is Record<string, ShaderModuleUniformValue | undefined> {
+  return (
+    Boolean(value) &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    !ArrayBuffer.isView(value)
+  );
+}
+
+function isShaderInputsModuleWithDependencies(
+  module: ShaderInputsModule | undefined
+): module is ShaderInputsModule & {dependencies: NonNullable<ShaderInputsModule['dependencies']>} {
+  return Boolean(module?.dependencies);
+}

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

@@ -0,0 +1,65 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {ComputeShaderLayout, ShaderLayout} from '@luma.gl/core';
+import type {ShaderModule} from '@luma.gl/shadertools';
+
+type AnyShaderLayout = ShaderLayout | ComputeShaderLayout;
+
+export function mergeShaderModuleBindingsIntoLayout<TShaderLayout extends AnyShaderLayout>(
+  shaderLayout: TShaderLayout | null | undefined,
+  modules: ShaderModule[]
+): TShaderLayout | null | undefined {
+  if (!shaderLayout || !modules.some(module => module.bindingLayout?.length)) {
+    return shaderLayout;
+  }
+
+  const mergedLayout = {
+    ...shaderLayout,
+    bindings: shaderLayout.bindings.map(binding => ({...binding}))
+  } as TShaderLayout;
+
+  if ('attributes' in (shaderLayout || {})) {
+    (mergedLayout as ShaderLayout).attributes = (shaderLayout as ShaderLayout)?.attributes || [];
+  }
+
+  for (const module of modules) {
+    for (const bindingLayout of module.bindingLayout || []) {
+      for (const relatedBindingName of getRelatedBindingNames(bindingLayout.name)) {
+        const binding = mergedLayout.bindings.find(
+          candidate => candidate.name === relatedBindingName
+        );
+        if (binding?.group === 0) {
+          binding.group = bindingLayout.group;
+        }
+      }
+    }
+  }
+
+  return mergedLayout;
+}
+
+export function shaderModuleHasUniforms(module: ShaderModule): boolean {
+  return Boolean(module.uniformTypes && !isObjectEmpty(module.uniformTypes));
+}
+
+/** Returns binding-name aliases that should share the module-declared bind group. */
+function getRelatedBindingNames(bindingName: string): string[] {
+  const bindingNames = new Set<string>([bindingName, `${bindingName}Uniforms`]);
+
+  if (!bindingName.endsWith('Uniforms')) {
+    bindingNames.add(`${bindingName}Sampler`);
+  }
+
+  return [...bindingNames];
+}
+
+function isObjectEmpty(obj: object): boolean {
+  // @ts-ignore key is intentionally unused
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  for (const key in obj) {
+    return false;
+  }
+  return true;
+}

package/dist/dynamic-texture/mipmaps.d.ts

@@ -1,6 +0,0 @@
-import type { Device, Texture } from '@luma.gl/core';
-/**
- * Generates mip levels from level 0 to the last mip for an existing texture.
- */
-export declare function generateMipmap(device: Device, texture: Texture): void;
-//# sourceMappingURL=mipmaps.d.ts.map

package/dist/dynamic-texture/mipmaps.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mipmaps.d.ts","sourceRoot":"","sources":["../../src/dynamic-texture/mipmaps.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,MAAM,EAAE,OAAO,EAAoC,MAAM,eAAe,CAAC;AAsBtF;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAwBrE"}