@luma.gl/engine 9.0.0-alpha.23 → 9.0.0-alpha.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/engine",
-  "version": "9.0.0-alpha.23",
+  "version": "9.0.0-alpha.25",
   "description": "WebGL2 Components for High Performance Rendering and Computation",
   "type": "module",
   "license": "MIT",
@@ -40,13 +40,13 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.0.0",
-    "@luma.gl/api": "9.0.0-alpha.23",
-    "@luma.gl/constants": "9.0.0-alpha.23",
-    "@luma.gl/shadertools": "9.0.0-alpha.23",
-    "@luma.gl/webgl": "9.0.0-alpha.23",
+    "@luma.gl/api": "9.0.0-alpha.25",
+    "@luma.gl/constants": "9.0.0-alpha.25",
+    "@luma.gl/shadertools": "9.0.0-alpha.25",
+    "@luma.gl/webgl": "9.0.0-alpha.25",
     "@math.gl/core": "4.0.0-alpha.4",
     "@probe.gl/log": "^4.0.2",
     "@probe.gl/stats": "^4.0.2"
   },
-  "gitHead": "5e4a30497333bea4be8f2b3f3db33c0b67931b9c"
+  "gitHead": "a91e00399e59c1b5310bdfd842648238c5abf908"
 }

package/src/geometry/geometry.ts

@@ -1,7 +1,7 @@
 // luma.gl, MIT license
 import type {PrimitiveTopology, TypedArray} from '@luma.gl/api';
 import {uid, assert} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+import {GL} from '@luma.gl/constants';
 
 /**
  * Rendering primitives - "topology" specifies how to extract primitives from vertices.

package/src/index.ts

@@ -23,6 +23,11 @@ export {PipelineFactory} from './lib/pipeline-factory';
 // Utils
 export {ClipSpace} from './lib/clip-space';
 
+// Scenegraph Core nodes
+export {ScenegraphNode} from './scenegraph/scenegraph-node';
+export {GroupNode} from './scenegraph/group-node';
+export {ModelNode} from './scenegraph/model-node';
+
 // Geometries
 export {Geometry} from './geometry/geometry';
 

package/src/lib/clip-space.ts

@@ -1,6 +1,6 @@
 
 // ClipSpace
-import GL from '@luma.gl/constants';
+import {GL} from '@luma.gl/constants';
 import {Device, glsl} from '@luma.gl/api';
 import {WebGLDevice} from '@luma.gl/webgl';
 import {Model, ModelProps} from '../model/model';

package/src/scenegraph/group-node.ts

@@ -0,0 +1,103 @@
+import {Matrix4, Vector3} from '@math.gl/core';
+import {log} from '@luma.gl/api';
+import {ScenegraphNode, ScenegraphNodeProps} from './scenegraph-node';
+
+export type GroupNodeProps = ScenegraphNodeProps & {
+  children?: ScenegraphNode[];
+}
+
+export class GroupNode extends ScenegraphNode {
+  children: ScenegraphNode[];
+
+  constructor(children: ScenegraphNode[]);
+  constructor(props?: GroupNodeProps);
+
+  constructor(props: ScenegraphNode[] | GroupNodeProps = {}) {
+    props = Array.isArray(props) ? {children: props} : props;
+    const {children = []} = props;
+    log.assert(
+      children.every((child) => child instanceof ScenegraphNode),
+      'every child must an instance of ScenegraphNode'
+    );
+    super(props);
+    this.children = children;
+  }
+
+  override getBounds(): [number[], number[]] | null {
+    const result: [number[], number[]] = [[Infinity, Infinity, Infinity], [-Infinity, -Infinity, -Infinity]];
+
+    this.traverse((node, {worldMatrix}) => {
+      const bounds = node.getBounds();
+      if (!bounds) {
+        return;
+      }
+      const [min, max] = bounds;
+      const center = new Vector3(min).add(max).divide([2, 2, 2]);
+      worldMatrix.transformAsPoint(center, center);
+      const halfSize = new Vector3(max).subtract(min).divide([2, 2, 2]);
+      worldMatrix.transformAsVector(halfSize, halfSize);
+
+      for (let v = 0; v < 8; v++) {
+        // Test all 8 corners of the box
+        const position = new Vector3(
+          v & 0b001 ? -1 : 1,
+          v & 0b010 ? -1 : 1,
+          v & 0b100 ? -1 : 1
+        ).multiply(halfSize).add(center);
+
+        for (let i = 0; i < 3; i++) {
+          result[0][i] = Math.min(result[0][i], position[i]);
+          result[1][i] = Math.max(result[1][i], position[i]);
+        }
+      }
+    });
+    if (!Number.isFinite(result[0][0])) {
+      return null;
+    }
+    return result;
+  }
+
+  override destroy(): void {
+    this.children.forEach((child) => child.destroy());
+    this.removeAll();
+    super.destroy();
+  }
+
+  // Unpacks arrays and nested arrays of children
+  add(...children: (ScenegraphNode | ScenegraphNode[])[]): this {
+    for (const child of children) {
+      if (Array.isArray(child)) {
+        this.add(...child);
+      } else {
+        this.children.push(child);
+      }
+    }
+    return this;
+  }
+
+  remove(child: ScenegraphNode): this {
+    const children = this.children;
+    const indexOf = children.indexOf(child);
+    if (indexOf > -1) {
+      children.splice(indexOf, 1);
+    }
+    return this;
+  }
+
+  removeAll(): this {
+    this.children = [];
+    return this;
+  }
+
+  traverse(visitor: (node: ScenegraphNode, context: {worldMatrix: Matrix4}) => void, {worldMatrix = new Matrix4()} = {}) {
+    const modelMatrix = new Matrix4(worldMatrix).multiplyRight(this.matrix);
+
+    for (const child of this.children) {
+      if (child instanceof GroupNode) {
+        child.traverse(visitor, {worldMatrix: modelMatrix});
+      } else {
+        visitor(child, {worldMatrix: modelMatrix});
+      }
+    }
+  }
+}

package/src/scenegraph/model-node.ts

@@ -0,0 +1,50 @@
+import {RenderPass} from '@luma.gl/api';
+import {ScenegraphNode, ScenegraphNodeProps} from './scenegraph-node';
+import {Model} from '../model/model';
+
+export type ModelNodeProps = ScenegraphNodeProps & {
+  model: Model;
+  managedResources?: any[];
+  bounds?: [number[], number[]];
+}
+
+export class ModelNode extends ScenegraphNode {
+  readonly model: Model;
+  bounds: [number[], number[]] | null = null;
+  managedResources: any[];
+
+  // TODO - is this used? override callbacks to make sure we call them with this
+  // onBeforeRender = null;
+  // onAfterRender = null;
+  // AfterRender = null;
+
+  constructor(props: ModelNodeProps) {
+    super(props);
+
+    // Create new Model or used supplied Model
+    this.model = props.model;
+    this.managedResources = props.managedResources || [];
+    this.bounds = props.bounds || null;
+    this.setProps(props);
+  }
+
+  override getBounds(): [number[], number[]] | null {
+    return this.bounds;
+  }
+
+  override destroy(): void {
+    if (this.model) {
+      this.model.destroy();
+      // @ts-expect-error
+      this.model = null;
+    }
+    this.managedResources.forEach((resource) => resource.destroy());
+    this.managedResources = [];
+  }
+
+  // Expose model methods
+  draw(renderPass?: RenderPass) {
+    // Return value indicates if something was actually drawn
+    return this.model.draw(renderPass);
+  }
+}

package/src/scenegraph/scenegraph-node.ts

@@ -0,0 +1,204 @@
+import {assert, uid, NumericArray} from '@luma.gl/api';
+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?: NumericArray;
+  position?: NumericArray;
+  rotation?: NumericArray;
+  scale?: NumericArray;
+  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/transform/transform.ts

@@ -2,7 +2,7 @@
 
 import {Device, Buffer, Texture, Framebuffer} from '@luma.gl/api';
 import {getShaderInfo, getPassthroughFS} from '@luma.gl/shadertools';
-import GL from '@luma.gl/constants';
+import {GL} from '@luma.gl/constants';
 import {WebGLDevice, GLParameters} from '@luma.gl/webgl';
 import {Model} from '../model/model';