@luma.gl/engine 9.0.0-alpha.5 → 9.0.0-alpha.50

package/src/scenegraph/scenegraph-node.ts

@@ -0,0 +1,204 @@
+import {assert, uid, NumberArray} from '@luma.gl/core';
+import {Vector3, Matrix4} from '@math.gl/core';
+
+/** Properties for creating a new Scenegraph */
+export type ScenegraphNodeProps = {
+  id?: string;
+  /** whether to display the object at all */
+  display?: boolean;
+  matrix?: NumberArray;
+  position?: NumberArray;
+  rotation?: NumberArray;
+  scale?: NumberArray;
+  update?: boolean
+};
+
+export class ScenegraphNode {
+  readonly id: string;
+  matrix: Matrix4 = new Matrix4();
+
+  display = true; 
+  position = new Vector3();
+  rotation = new Vector3();
+  scale = new Vector3(1, 1, 1);
+  userData: Record<string, unknown> = {};
+
+  props: ScenegraphNodeProps = {};
+
+  constructor(props: ScenegraphNodeProps = {}) {
+    const {id} = props;
+
+    this.id = id || uid(this.constructor.name);
+
+    this._setScenegraphNodeProps(props);
+  }
+
+  getBounds(): [number[], number[]] | null {
+    return null;
+  }
+
+  destroy(): void {}
+
+  /** @deprecated use .destroy() */
+  delete(): void {
+    this.destroy();
+  }
+  setProps(props: ScenegraphNodeProps): this {
+    this._setScenegraphNodeProps(props);
+    return this;
+  }
+
+  toString(): string {
+    return `{type: ScenegraphNode, id: ${this.id})}`;
+  }
+
+  setPosition(position: any): this {
+    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');
+    this.rotation = rotation;
+    return this;
+  }
+
+  setScale(scale: any): this {
+    assert(scale.length === 3, 'setScale requires vector argument');
+    this.scale = scale;
+    return this;
+  }
+
+  setMatrix(matrix: any, copyMatrix: boolean = true): void {
+    if (copyMatrix) {
+      this.matrix.copy(matrix);
+    } else {
+      this.matrix = matrix;
+    }
+  }
+
+  setMatrixComponents(components: {
+    position?: any;
+    rotation?: any;
+    scale?: any;
+    update?: boolean;
+  }): this {
+    const {position, rotation, scale, update = true} = components;
+    if (position) {
+      this.setPosition(position);
+    }
+    if (rotation) {
+      this.setRotation(rotation);
+    }
+    if (scale) {
+      this.setScale(scale);
+    }
+    if (update) {
+      this.updateMatrix();
+    }
+    return this;
+  }
+
+  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);
+    return this;
+  }
+
+  update(options: {position?: any; rotation?: any; scale?: any} = {}): this {
+    const {position, rotation, scale} = options;
+    if (position) {
+      this.setPosition(position);
+    }
+    if (rotation) {
+      this.setRotation(rotation);
+    }
+    if (scale) {
+      this.setScale(scale);
+    }
+    this.updateMatrix();
+    return this;
+  }
+
+  getCoordinateUniforms(
+    viewMatrix: any,
+    modelMatrix?: any
+  ): {
+    viewMatrix: any;
+    modelMatrix: any;
+    objectMatrix: any;
+    worldMatrix: any;
+    worldInverseMatrix: any;
+    worldInverseTransposeMatrix: any;
+  } {
+    // TODO - solve multiple class problem
+    // assert(viewMatrix instanceof Matrix4);
+    assert(viewMatrix);
+    modelMatrix = modelMatrix || this.matrix;
+    const worldMatrix = new Matrix4(viewMatrix).multiplyRight(modelMatrix);
+    const worldInverse = worldMatrix.invert();
+    const worldInverseTranspose = worldInverse.transpose();
+
+    return {
+      viewMatrix,
+      modelMatrix,
+      objectMatrix: modelMatrix,
+      worldMatrix,
+      worldInverseMatrix: worldInverse,
+      worldInverseTransposeMatrix: worldInverseTranspose
+    };
+  }
+
+  // TODO - copied code, not yet vetted
+  /*
+  transform() {
+    if (!this.parent) {
+      this.endPosition.set(this.position);
+      this.endRotation.set(this.rotation);
+      this.endScale.set(this.scale);
+    } else {
+      const parent = this.parent;
+      this.endPosition.set(this.position.add(parent.endPosition));
+      this.endRotation.set(this.rotation.add(parent.endRotation));
+      this.endScale.set(this.scale.add(parent.endScale));
+    }
+
+    const ch = this.children;
+    for (let i = 0; i < ch.length; ++i) {
+      ch[i].transform();
+    }
+
+    return this;
+  }
+  */
+
+  _setScenegraphNodeProps(props: ScenegraphNodeProps): void {
+    if ('display' in props) {
+      this.display = props.display;
+    }
+
+    if ('position' in props) {
+      this.setPosition(props.position);
+    }
+    if ('rotation' in props) {
+      this.setRotation(props.rotation);
+    }
+    if ('scale' in props) {
+      this.setScale(props.scale);
+    }
+
+    // Matrix overwrites other props
+    if ('matrix' in props) {
+      this.setMatrix(props.matrix);
+    }
+
+    Object.assign(this.props, props);
+  }
+}

package/src/shader-inputs.ts

@@ -0,0 +1,132 @@
+// luma.gl, MIT license
+import type {UniformValue, Texture, Sampler} from '@luma.gl/core';
+import {log} from '@luma.gl/core';
+// import type {ShaderUniformType, UniformValue, UniformFormat, UniformInfoDevice, Texture, Sampler} from '@luma.gl/core';
+import {_resolveModules, ShaderModuleInstance} from '@luma.gl/shadertools'
+
+
+/** Minimal ShaderModule subset, we don't need shader code etc */
+export type ShaderModuleInputs<
+  PropsT extends Record<string, unknown> = Record<string, unknown>,
+  UniformsT extends Record<string, UniformValue> = Record<string, UniformValue>,
+  BindingsT extends Record<string, Texture | Sampler> = Record<string, Texture | Sampler>
+> = {
+  defaultUniforms?: UniformsT;
+  getUniforms?: (settings: Partial<PropsT>, prevUniforms?: UniformsT) => UniformsT;
+
+  /** Not used. Used to access props type */
+  props?: PropsT;
+
+  bindings?: Record<
+    keyof BindingsT,
+    {
+      location: number;
+      type: 'texture' | 'sampler' | 'uniforms';
+    }
+  >;
+
+  uniformTypes?: any;
+};
+
+/**
+ * ShaderInputs holds uniform and binding values for one or more shader modules,
+ * - It can generate binary data for any uniform buffer
+ * - It can manage a uniform buffer for each block
+ * - It can update managed uniform buffers with a single call
+ * - It performs some book keeping on what has changed to minimize unnecessary writes to uniform buffers.
+ */
+export class ShaderInputs<
+  ShaderPropsT extends Partial<Record<string, Record<string, unknown>>> = Partial<
+    Record<string, Record<string, unknown>>
+  >
+> {
+  /** 
+   * The map of modules 
+   * @todo should should this include the resolved dependencies?
+   */
+  modules: Readonly<{[P in keyof ShaderPropsT]: ShaderModuleInputs<ShaderPropsT[P]>}>;
+
+  /** Stores the uniform values for each module */
+  moduleUniforms: Record<keyof ShaderPropsT, Record<string, UniformValue>>;
+  /** Stores the uniform bindings for each module  */
+  moduleBindings: Record<keyof ShaderPropsT, Record<string, Texture | Sampler>>;
+  /** Tracks if uniforms have changed */
+  moduleUniformsChanged: Record<keyof ShaderPropsT, false | string>;
+
+  /**
+   * Create a new UniformStore instance
+   * @param modules
+   */
+  constructor(modules: {[P in keyof ShaderPropsT]: ShaderModuleInputs<ShaderPropsT[P]>}) {
+    // TODO - get all dependencies from modules
+    const allModules =_resolveModules(Object.values(modules));
+    log.log(1, 'Creating ShaderInputs with modules', allModules.map(m => m.name))();
+
+    // Store the module definitions and create storage for uniform values and binding values, per module
+    this.modules = modules;
+    this.moduleUniforms = {} as Record<keyof ShaderPropsT, Record<string, UniformValue>>;
+    this.moduleBindings = {} as Record<keyof ShaderPropsT, Record<string, Texture | Sampler>>;
+
+    // Initialize the modules
+    for (const [name, module] of Object.entries(modules)) {
+      const moduleName = name as keyof ShaderPropsT;
+
+      // Get default uniforms from module
+      this.moduleUniforms[moduleName] = module.defaultUniforms || {};
+      this.moduleBindings[moduleName] = {};
+    }
+  }
+
+  /** Destroy */
+  destroy(): void {}
+
+  /**
+   * Set module props
+   */
+  setProps(props: Partial<{[P in keyof ShaderPropsT]?: Partial<ShaderPropsT[P]>}>): void {
+    for (const name of Object.keys(props)) {
+      const moduleName = name as keyof ShaderPropsT;
+      const moduleProps = props[moduleName];
+      const module = this.modules[moduleName];
+
+      const oldUniforms = this.moduleUniforms[moduleName];  
+      const uniforms = module.getUniforms?.(moduleProps, this.moduleUniforms[moduleName]) || moduleProps as any;
+      // console.error(uniforms)
+      this.moduleUniforms[moduleName] = {...oldUniforms, ...uniforms};
+      // this.moduleUniformsChanged ||= moduleName;
+
+      // console.log(`setProps(${String(moduleName)}`, moduleName, this.moduleUniforms[moduleName])
+
+      // TODO - Get Module bindings
+      // const bindings = module.getBindings?.(moduleProps);
+      // this.moduleUniforms[moduleName] = bindings;
+    }
+  }
+
+  /** Merges all bindings for the shader (from the various modules) */
+  // getUniformBlocks(): Record<string, Texture | Sampler> {
+  //   return this.moduleUniforms;
+  // }
+
+  /** 
+   * Return the map of modules 
+   * @todo should should this include the resolved dependencies?
+   */
+  getModules(): ShaderModuleInstance[] {
+    return Object.values(this.modules);
+  }
+
+  /** Get all uniform values for all modules */
+  getUniformValues(): Record<keyof ShaderPropsT, Record<string, UniformValue>> {
+    return this.moduleUniforms;
+  }
+
+  /** Merges all bindings for the shader (from the various modules) */
+  getBindings(): Record<string, Texture | Sampler> {
+    const bindings = {} as Record<string, Texture | Sampler>;
+    for (const moduleBindings of Object.values(this.moduleBindings)) {
+      Object.assign(bindings, moduleBindings);
+    }
+    return bindings;
+  }
+}

package/src/transform/buffer-transform.ts

@@ -0,0 +1,94 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import {Device, Buffer, BufferRange, TransformFeedback, assert, RenderPassProps} from '@luma.gl/core';
+import {getPassthroughFS} from '@luma.gl/shadertools';
+import {Model} from '../model/model';
+import type { ModelProps } from '..';
+
+/**
+ * Properties for creating a {@link BufferTransform}
+ * @deprecated
+ */
+export type BufferTransformProps = Omit<ModelProps, 'fs'> & {
+  fs?: ModelProps['fs']; // override as optional
+  feedbackBuffers?: Record<string, Buffer | BufferRange>;
+};
+
+/**
+ * Creates a pipeline for buffer→buffer transforms.
+ * @deprecated
+ */
+export class BufferTransform {
+  readonly device: Device;
+  readonly model: Model;
+  readonly transformFeedback: TransformFeedback;
+
+  /** @deprecated Use device feature test. */
+  static isSupported(device: Device): boolean {
+    return device.features.has('transform-feedback-webgl2');
+  }
+
+  constructor(device: Device, props: BufferTransformProps = Model.defaultProps) {
+    assert(device.features.has('transform-feedback-webgl2'), 'Device must support transform feedback');
+
+    this.device = device;
+
+    this.model = new Model(this.device, {
+      id: props.id || 'buffer-transform-model',
+      fs: props.fs || getPassthroughFS({version: 300}),
+      topology: props.topology || 'point-list',
+      ...props,
+    });
+
+    this.transformFeedback = this.device.createTransformFeedback({
+      layout: this.model.pipeline.shaderLayout,
+      buffers: props.feedbackBuffers,
+    });
+
+    this.model.setTransformFeedback(this.transformFeedback);
+
+    Object.seal(this);
+  }
+
+  /** Destroy owned resources. */
+  destroy(): void {
+    if (this.model) {
+      this.model.destroy();
+    }
+  }
+
+  /** @deprecated Use {@link destroy}. */
+  delete(): void {
+    this.destroy();
+  }
+
+  /** Run one transform loop. */
+  run(options?: RenderPassProps): void {
+    const renderPass = this.device.beginRenderPass(options);
+    this.model.draw(renderPass);
+    renderPass.end();
+  }
+
+  /** @deprecated */
+  update(...args: any[]): void {
+    // TODO(v9): Method should likely be removed for v9. Keeping a method stub
+    // to assist with migrating DeckGL usage.
+    // eslint-disable-next-line no-console
+    console.warn('TextureTransform#update() not implemented');
+  }
+
+  /** Returns the {@link Buffer} or {@link BufferRange} for given varying name. */
+  getBuffer(varyingName: string): Buffer | BufferRange | null {
+    return this.transformFeedback.getBuffer(varyingName);
+  }
+
+  readAsync(varyingName: string): Promise<Uint8Array> {
+    const result = this.getBuffer(varyingName);
+    if (result instanceof Buffer) {
+      return result.readAsync();
+    }
+    const {buffer, byteOffset = 0, byteLength = buffer.byteLength} = result;
+    return buffer.readAsync(byteOffset, byteLength);
+  }
+}

package/src/transform/texture-transform.ts

@@ -0,0 +1,169 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import { Buffer, Device, Framebuffer, RenderPassProps, Sampler, Texture } from '@luma.gl/core';
+import { Model, ModelProps } from '../model/model';
+import { getPassthroughFS } from '@luma.gl/shadertools';
+
+/**
+ * Properties for creating a {@link TextureTransform}
+ * @deprecated
+ */
+export type TextureTransformProps = Omit<ModelProps, 'fs'> & {
+  fs?: ModelProps['fs']; // override as optional
+  /** @deprecated TODO(donmccurdy): Needed? */
+  inject?: Record<string, string>;
+  /** @deprecated TODO(donmccurdy): Needed? */
+  framebuffer?: Framebuffer;
+  /** @deprecated TODO(donmccurdy): Model already handles this? */
+  sourceBuffers?: Record<string, Buffer>;
+  /** @deprecated TODO(donmccurdy): Model already handles this? */
+  sourceTextures?: Record<string, Texture>;
+  targetTexture: Texture;
+  targetTextureChannels: 1 | 2 | 3 | 4;
+  targetTextureVarying: string;
+};
+
+
+type TextureBinding = {
+  sourceBuffers: Record<string, Buffer>;
+  sourceTextures: Record<string, Texture>;
+  targetTexture: Texture;
+  framebuffer?: Framebuffer;
+};
+
+const FS_OUTPUT_VARIABLE = 'transform_output';
+
+/**
+ * Creates a pipeline for texture→texture transforms.
+ * @deprecated
+ */
+export class TextureTransform {
+  readonly device: Device;
+  readonly model: Model;
+  readonly sampler: Sampler;
+  
+  currentIndex = 0;
+  samplerTextureMap: Record<string, any> | null = null;
+  bindings: TextureBinding[] = []; // each element is an object : {sourceTextures, targetTexture, framebuffer}
+  resources: Record<string, any> = {}; // resources to be deleted
+
+  constructor(device: Device, props: TextureTransformProps) {
+    this.device = device;
+
+    // For precise picking of element IDs.
+    this.sampler = device.createSampler({
+      addressModeU: 'clamp-to-edge',
+      addressModeV: 'clamp-to-edge',
+      minFilter: 'nearest',
+      magFilter: 'nearest',
+      mipmapFilter: 'nearest',
+    });
+
+    this.model = new Model(this.device, {
+      id: props.id || 'texture-transform-model',
+      fs: props.fs || getPassthroughFS({
+        version: 300,
+        input: props.targetTextureVarying,
+        inputChannels: props.targetTextureChannels,
+        output: FS_OUTPUT_VARIABLE
+      }),
+      vertexCount: props.vertexCount, // TODO(donmccurdy): Naming?
+      ...props
+    });
+
+    this._initialize(props);
+    Object.seal(this);
+  }
+
+  // Delete owned resources.
+  destroy(): void {}
+
+  /** @deprecated Use {@link destroy}. */
+  delete(): void {
+    this.destroy();
+  }
+
+  run(options?: RenderPassProps): void {
+    const {framebuffer} = this.bindings[this.currentIndex];
+    const renderPass = this.device.beginRenderPass({framebuffer, ...options});
+    this.model.draw(renderPass);
+    renderPass.end();
+  }
+
+  /** @deprecated */
+  update(...args: any[]): void {
+    // TODO(v9): Method should likely be removed for v9. Keeping a method stub
+    // to assist with migrating DeckGL usage.
+    // eslint-disable-next-line no-console
+    console.warn('TextureTransform#update() not implemented');
+  }
+
+
+  getData({packed = false} = {}) {
+    // TODO(v9): Method should likely be removed for v9. Keeping a method stub
+    // to assist with migrating DeckGL usage.
+    throw new Error('getData() not implemented');
+  }
+
+  getTargetTexture(): Texture {
+    const {targetTexture} = this.bindings[this.currentIndex];
+    return targetTexture;
+  }
+
+
+  getFramebuffer(): Framebuffer {
+    const currentResources = this.bindings[this.currentIndex];
+    return currentResources.framebuffer;
+  }
+
+  // Private
+
+  _initialize(props: TextureTransformProps): void {
+    this._updateBindings(props);
+  }
+
+  _updateBindings(props: TextureTransformProps) {
+    this.bindings[this.currentIndex] = this._updateBinding(this.bindings[this.currentIndex], props);
+  }
+
+  _updateBinding(
+    binding: TextureBinding,
+    {sourceBuffers, sourceTextures, targetTexture}: TextureTransformProps
+  ): TextureBinding {
+    if (!binding) {
+      binding = {
+        sourceBuffers: {},
+        sourceTextures: {},
+        targetTexture: null
+      };
+    }
+    Object.assign(binding.sourceTextures, sourceTextures);
+    Object.assign(binding.sourceBuffers, sourceBuffers);
+    if (targetTexture) {
+      binding.targetTexture = targetTexture;
+      const {width, height} = targetTexture;
+      // TODO(donmccurdy): When is this called, and is this expected?
+      if (binding.framebuffer) {
+        binding.framebuffer.destroy();
+      }
+      binding.framebuffer = this.device.createFramebuffer({
+        id: 'transform-framebuffer',
+        width,
+        height,
+        colorAttachments: [targetTexture]
+      });
+      binding.framebuffer.resize({width, height});
+    }
+    return binding;
+  }
+
+  // set texture filtering parameters on source textures.
+  _setSourceTextureParameters(): void {
+    const index = this.currentIndex;
+    const {sourceTextures} = this.bindings[index];
+    for (const name in sourceTextures) {
+      sourceTextures[name].sampler = this.sampler;
+    }
+  }
+}

package/dist/bundle.d.ts

@@ -1,2 +0,0 @@
-declare const moduleExports: any;
-//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,aAAa,KAAqB,CAAC"}

package/dist/bundle.js

@@ -1,5 +0,0 @@
-const moduleExports = require('./index');
-
-globalThis.luma = globalThis.luma || {};
-module.exports = Object.assign(globalThis.luma, moduleExports);
-//# sourceMappingURL=bundle.js.map

package/dist/bundle.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/bundle.ts"],"names":["moduleExports","require","globalThis","luma","module","exports","Object","assign"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,IAAX,GAAkBD,UAAU,CAACC,IAAX,IAAmB,EAArC;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,IAAzB,EAA+BH,aAA/B,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.luma = globalThis.luma || {};\nmodule.exports = Object.assign(globalThis.luma, moduleExports);\n"],"file":"bundle.js"}

package/dist/geometry/primitive-utils.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=primitive-utils.d.ts.map

package/dist/geometry/primitive-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"primitive-utils.d.ts","sourceRoot":"","sources":["../../src/geometry/primitive-utils.ts"],"names":[],"mappings":""}

package/dist/geometry/primitive-utils.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=primitive-utils.js.map

package/dist/geometry/primitive-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"primitive-utils.js"}

package/dist/lib/animation-loop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"animation-loop.d.ts","sourceRoot":"","sources":["../../src/lib/animation-loop.ts"],"names":[],"mappings":"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"}