@luma.gl/engine 9.0.0-alpha.8 → 9.0.0-beta.1

package/src/geometry/geometry.ts

@@ -1,91 +1,61 @@
 // luma.gl, MIT license
-import type {TypedArray} from '@luma.gl/api';
-import {uid, assert} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-
-/**
- * Rendering primitives - "topology" specifies how to extract primitives from vertices.
- * @deprecated - use string constants instead
- */
-export type GLTopology =
-  GL.POINTS |  // draw single points.
-  GL.LINES |  // draw lines. Each vertex connects to the one after it.
-  GL.LINE_LOOP |  // draw lines. Each set of two vertices is treated as a separate line segment.
-  GL.LINE_STRIP |  // draw a connected group of line segments from the first vertex to the last
-  GL.TRIANGLES |  // draw triangles. Each set of three vertices creates a separate triangle.
-  GL.TRIANGLE_STRIP |  // draw a connected group of triangles.
-  GL.TRIANGLE_FAN // draw a connected group of triangles.
-  ;
-
-export type GeometryAttribute = {
-  size?: number;
-  value: TypedArray;
-  [key: string]: any
-}
+import type {PrimitiveTopology, TypedArray} from '@luma.gl/core';
+import {uid, assert} from '@luma.gl/core';
 
 export type GeometryProps = {
   id?: string;
-  attributes?: Record<string, GeometryAttribute | TypedArray>,
-  indices?: GeometryAttribute | TypedArray;
-  vertexCount?: number;
   /** Determines how vertices are read from the 'vertex' attributes */
-  topology?: 'point-list' | 'line-list' | 'line-strip' | 'triangle-list' | 'triangle-strip';
-  /** @deprecated */
-  drawMode?: GLTopology;
+  topology:
+    | 'point-list'
+    | 'line-list'
+    | 'line-strip'
+    | 'line-loop-webgl'
+    | 'triangle-list'
+    | 'triangle-strip'
+    | 'triangle-fan-webgl';
+  /** Auto calculated from attributes if not provided */
+  vertexCount?: number;
+  attributes?: Record<string, GeometryAttribute | TypedArray>;
+  indices?: GeometryAttribute | TypedArray;
 };
 
-type GeometryAttributes = {
-  POSITION: GeometryAttribute,
-  NORMAL: GeometryAttribute,
-  TEXCOORD_0: GeometryAttribute,
-  COLOR_0?: GeometryAttribute,
-  indices?: {size?: number, value: Uint32Array | Uint16Array};
+export type GeometryAttributes = {
+  POSITION: GeometryAttribute;
+  NORMAL: GeometryAttribute;
+  TEXCOORD_0: GeometryAttribute;
+  COLOR_0?: GeometryAttribute;
+  indices?: GeometryAttribute & {size: 1; value: Uint32Array | Uint16Array};
 };
 
-export default class Geometry {
-  /** @deprecated */
-  static DRAW_MODE = {
-    POINTS: GL.POINTS,  // draw single points.
-    LINES: GL.LINES,  // draw lines. Each vertex connects to the one after it.
-    LINE_LOOP: GL.LINE_LOOP,  // draw lines. Each set of two vertices is treated as a separate line segment.
-    LINE_STRIP: GL.LINE_STRIP,  // draw a connected group of line segments from the first vertex to the last
-    TRIANGLES: GL.TRIANGLES,  // draw triangles. Each set of three vertices creates a separate triangle.
-    TRIANGLE_STRIP: GL.TRIANGLE_STRIP,  // draw a connected group of triangles.
-    TRIANGLE_FAN: GL.TRIANGLE_FAN // draw a connected group of triangles.
-  };
+export type GeometryAttribute = {
+  size?: number;
+  value: TypedArray;
+  [key: string]: any;
+};
 
+export class Geometry {
   readonly id: string;
-  userData: Record<string, unknown> = {};
-
   /** Determines how vertices are read from the 'vertex' attributes */
-  topology?: 'point-list' | 'line-list' | 'line-strip' | 'triangle-list' | 'triangle-strip';
-  /** @deprecated */
-  readonly drawMode: GLTopology = GL.TRIANGLES;
-
+  readonly topology?: PrimitiveTopology;
   readonly vertexCount: number;
+  readonly indices?: GeometryAttribute;
   readonly attributes: {
-    POSITION: GeometryAttribute,
-    NORMAL: GeometryAttribute,
-    TEXCOORD_0: GeometryAttribute,
-    COLOR_0?: GeometryAttribute,
+    POSITION: GeometryAttribute;
+    NORMAL: GeometryAttribute;
+    TEXCOORD_0: GeometryAttribute;
+    COLOR_0?: GeometryAttribute;
+    [key: string]: GeometryAttribute | undefined;
   };
-  readonly indices?: Uint16Array | Uint32Array;
 
-  constructor(props: GeometryProps = {}) {
-    const {
-      id = uid('geometry'),
-      drawMode = GL.TRIANGLES,
-      attributes = {},
-      indices = null,
-      vertexCount = null
-    } = props;
+  userData: Record<string, unknown> = {};
 
-    this.id = id;
-    this.drawMode = drawMode;
-    this.topology = props.topology || convertToTopology(drawMode);
+  constructor(props: GeometryProps) {
+    const {attributes = {}, indices = null, vertexCount = null} = props;
+
+    this.id = props.id || uid('geometry');
+    this.topology = props.topology;
 
     if (indices) {
-      // @ts-expect-error
       this.indices = ArrayBuffer.isView(indices) ? {value: indices, size: 1} : indices;
     }
 
@@ -93,9 +63,10 @@ export default class Geometry {
     this.attributes = {};
 
     for (const [attributeName, attributeValue] of Object.entries(attributes)) {
-
       // Wrap "unwrapped" arrays and try to autodetect their type
-      const attribute: GeometryAttribute = ArrayBuffer.isView(attributeValue) ? {value: attributeValue} : attributeValue;
+      const attribute: GeometryAttribute = ArrayBuffer.isView(attributeValue)
+        ? {value: attributeValue}
+        : attributeValue;
 
       assert(
         ArrayBuffer.isView(attribute.value),
@@ -109,36 +80,31 @@ export default class Geometry {
       // Move indices to separate field
       if (attributeName === 'indices') {
         assert(!this.indices);
-      // @ts-expect-error
-      this.indices = attribute;
+        this.indices = attribute;
       } else {
         this.attributes[attributeName] = attribute;
       }
     }
 
-      // @ts-expect-error
-      if (this.indices && this.indices.isIndexed !== undefined) {
+    if (this.indices && this.indices.isIndexed !== undefined) {
       this.indices = Object.assign({}, this.indices);
-      // @ts-expect-error
       delete this.indices.isIndexed;
     }
 
     this.vertexCount = vertexCount || this._calculateVertexCount(this.attributes, this.indices);
   }
 
-  /** @deprecated Use string topology constants instead */
-  get mode() {
-    return this.drawMode;
-  }
-
   getVertexCount(): number {
     return this.vertexCount;
   }
 
-  // Return an object with all attributes plus indices added as a field.
-  // getAttributes(): GeometryAttributes {
-  //   return this.indices ? {indices: this.indices, ...this.attributes} : this.attributes;
-  // }
+  /** 
+   * Return an object with all attributes plus indices added as a field.
+   * TODO Geometry types are a mess
+   */
+  getAttributes(): GeometryAttributes {
+    return this.indices ? {indices: this.indices, ...this.attributes} : this.attributes;
+  }
 
   // PRIVATE
 
@@ -146,23 +112,27 @@ export default class Geometry {
     return `Geometry ${this.id} attribute ${attributeName}`;
   }
 
-  // GeometryAttribute
-  // value: typed array
-  // type: indices, vertices, uvs
-  // size: elements per vertex
-  // target: WebGL buffer type (string or constant)
-  _setAttributes(attributes: Record<string, GeometryAttribute>, indices): this {
-
+  /**
+   * GeometryAttribute
+   * value: typed array
+   * type: indices, vertices, uvs
+   * size: elements per vertex
+   * target: WebGL buffer type (string or constant)
+   * 
+   * @param attributes 
+   * @param indices 
+   * @returns 
+   */
+  _setAttributes(attributes: Record<string, GeometryAttribute>, indices: any): this {
     return this;
   }
 
-  _calculateVertexCount(attributes, indices): number {
+  _calculateVertexCount(attributes: GeometryAttributes, indices: GeometryAttribute): number {
     if (indices) {
       return indices.value.length;
     }
     let vertexCount = Infinity;
-    for (const attributeName in attributes) {
-      const attribute = attributes[attributeName];
+    for (const attribute of Object.values(attributes)) {
       const {value, size, constant} = attribute;
       if (!constant && value && size >= 1) {
         vertexCount = Math.min(vertexCount, value.length / size);
@@ -173,18 +143,3 @@ export default class Geometry {
     return vertexCount;
   }
 }
-
-function convertToTopology(drawMode: GLTopology): 'point-list' | 'line-list' | 'line-strip' | 'triangle-list' | 'triangle-strip' {
-  switch (drawMode) {
-    case GL.POINTS: return 'point-list'; // draw single points.
-    case GL.LINES: return 'line-list'; // draw lines. Each vertex connects to the one after it.
-    case GL.LINE_STRIP: return 'line-strip';  // draw a connected group of line segments from the first vertex to the last
-    case GL.TRIANGLES: return 'triangle-list'; // draw triangles. Each set of three vertices creates a separate triangle.
-    case GL.TRIANGLE_STRIP: return 'triangle-strip'; // draw a connected group of triangles.
-
-    case GL.TRIANGLE_FAN: // draw a connected group of triangles.
-    case GL.LINE_LOOP:  // draw lines. Each set of two vertices is treated as a separate line segment.
-    default:
-      throw new Error(String(drawMode));
-  }
-}

package/src/geometry/gpu-geometry.ts

@@ -0,0 +1,125 @@
+import type {PrimitiveTopology, BufferLayout} from '@luma.gl/core';
+import {Device, Buffer, uid, assert, getVertexFormatFromAttribute} from '@luma.gl/core';
+import type {Geometry} from '../geometry/geometry';
+
+export type GPUGeometryProps = {
+  id?: string;
+  /** Determines how vertices are read from the 'vertex' attributes */
+  topology:
+    | 'point-list'
+    | 'line-list'
+    | 'line-strip'
+    | 'line-loop-webgl'
+    | 'triangle-list'
+    | 'triangle-strip'
+    | 'triangle-fan-webgl';
+  /** Auto calculated from attributes if not provided */
+  vertexCount: number;
+  bufferLayout: BufferLayout[];
+  indices?: Buffer | null;
+  attributes: Record<string, Buffer>;
+};
+
+export class GPUGeometry {
+  readonly id: string;
+  userData: Record<string, unknown> = {};
+
+  /** Determines how vertices are read from the 'vertex' attributes */
+  readonly topology?: PrimitiveTopology;
+  readonly bufferLayout: BufferLayout[] = [];
+
+  readonly vertexCount: number;
+  readonly indices?: Buffer | null;
+  readonly attributes: Record<string, Buffer>;
+
+  constructor(props: GPUGeometryProps) {
+    this.id = props.id || uid('geometry');
+    this.topology = props.topology;
+    this.indices = props.indices || null;
+    this.attributes = props.attributes;
+
+    this.vertexCount = props.vertexCount;
+
+    this.bufferLayout = props.bufferLayout || [];
+
+    if (this.indices) {
+      assert(this.indices.usage === Buffer.INDEX);
+    }
+  }
+
+  destroy(): void {
+    this.indices.destroy();
+    this.attributes.positions.destroy();
+    this.attributes.normals.destroy();
+    this.attributes.texCoords.destroy();
+    this.attributes.colors?.destroy();
+  }
+
+  getVertexCount(): number {
+    return this.vertexCount;
+  }
+
+  getAttributes(): Record<string, Buffer> {
+    return this.attributes;
+  }
+
+  getIndexes(): Buffer | null {
+    return this.indices;
+  }
+
+  _calculateVertexCount(positions: Buffer): number {
+    // Assume that positions is a fully packed float32x3 buffer
+    const vertexCount = positions.byteLength / 12;
+    return vertexCount;
+  }
+}
+
+export function makeGPUGeometry(device: Device, geometry: Geometry | GPUGeometry): GPUGeometry {
+  if (geometry instanceof GPUGeometry) {
+    return geometry;
+  }
+
+  const indices = getIndexBufferFromGeometry(device, geometry);
+  const {attributes, bufferLayout} = getAttributeBuffersFromGeometry(device, geometry);
+  return new GPUGeometry({
+    topology: geometry.topology || 'triangle-list',
+    bufferLayout,
+    vertexCount: geometry.vertexCount,
+    indices,
+    attributes
+  });
+}
+
+export function getIndexBufferFromGeometry(device: Device, geometry: Geometry): Buffer | undefined {
+  if (!geometry.indices) {
+    return undefined;
+  }
+  const data = geometry.indices.value;
+  return device.createBuffer({usage: Buffer.INDEX, data});
+}
+
+export function getAttributeBuffersFromGeometry(
+  device: Device,
+  geometry: Geometry
+): {attributes: Record<string, Buffer>, bufferLayout: BufferLayout[], vertexCount: number} {
+  const bufferLayout: BufferLayout[] = [];
+
+  const attributes: Record<string, Buffer> = {};
+  for (const [attributeName, attribute] of Object.entries(geometry.attributes)) {
+    let name: string = attributeName;
+    // TODO Map some GLTF attribute names (is this still needed?)
+    switch (attributeName) {
+      case 'POSITION': name = 'positions'; break;
+      case 'NORMAL': name = 'normals'; break;
+      case 'TEXCOORD_0': name = 'texCoords'; break;
+      case 'COLOR_0': name = 'colors'; break;
+    }
+    attributes[name] = device.createBuffer({data: attribute.value, id: `${attributeName}-buffer`});
+    const {value, size, normalized} = attribute;
+    bufferLayout.push({name, format: getVertexFormatFromAttribute(value, size, normalized)});
+  }
+
+  const vertexCount = geometry._calculateVertexCount(geometry.attributes, geometry.indices)
+
+  return {attributes, bufferLayout, vertexCount};
+}

package/src/geometry/gpu-table.ts

@@ -0,0 +1,41 @@
+/*
+export function getAttributeLayoutsFromGeometry(geometry: Geometry) {
+  const layouts: Record<string, {}> = {};
+  let indices = geometry.indices;
+
+  for (const [name, attribute] of Object.entries(geometry.attributes)) {
+    const remappedName = mapAttributeName(name);
+
+    if (attribute.constant) {
+      throw new Error('constant attributes not supported');
+    } else {
+      const typedArray = attribute.value;
+      // Create accessor by copying the attribute and removing `value``
+      const accessor = {...attribute};
+      delete accessor.value;
+      buffers[remappedName] = [device.createBuffer(typedArray), accessor];
+
+      inferAttributeAccessor(name, accessor);
+    }
+  }
+}
+
+export class Table {
+  length: number;
+  // columns: Record<string, TypedArray> = {};
+}
+
+export class GPUTable {
+  length: number;
+  columns: Record<string, Buffer> = {};
+}
+
+export function convertTableToGPUTable(table: Table) {
+  // for (const ) {}
+}
+
+export function renameTableColumns(table: Table, map: (name: string) => string) {
+  const newColumns = table.columns.reduce()
+  table.clone();
+}
+*/

package/src/index.ts

@@ -1,22 +1,43 @@
 // luma.gl Engine API
-export type {AnimationProps} from './lib/animation-props';
-export type {AnimationLoopProps} from './lib/animation-loop';
-export {AnimationLoop} from './lib/animation-loop';
-export {RenderLoop} from './lib/render-loop';
-export type {ModelProps} from './lib/model';
-export {default as Model} from './lib/model';
-
-export {PipelineFactory} from './lib/pipeline-factory';
 
 // Animation
 export {Timeline} from './animation/timeline';
 export {KeyFrames} from './animation/key-frames';
+export type {AnimationProps} from './animation-loop/animation-props';
+
+export {AnimationLoopTemplate} from './animation-loop/animation-loop-template';
+
+export type {AnimationLoopProps} from './animation-loop/animation-loop';
+export {AnimationLoop} from './animation-loop/animation-loop';
+
+export type {MakeAnimationLoopProps} from './animation-loop/make-animation-loop';
+export {makeAnimationLoop} from './animation-loop/make-animation-loop';
+
+export type {ModelProps} from './model/model';
+export {Model} from './model/model';
+
+// Transforms
+export type {BufferTransformProps} from './transform/buffer-transform';
+export {BufferTransform} from './transform/buffer-transform';
+export type {TextureTransformProps} from './transform/texture-transform';
+export {TextureTransform} from './transform/texture-transform';
+
+export {PipelineFactory} from './lib/pipeline-factory';
 
 // Utils
-// export {default as ClipSpace} from './lib/clip-space';
+export {ClipSpace} from './lib/clip-space';
+
+// Scenegraph Core nodes
+export {ScenegraphNode} from './scenegraph/scenegraph-node';
+export {GroupNode} from './scenegraph/group-node';
+export type {ModelNodeProps} from './scenegraph/model-node';
+export {ModelNode} from './scenegraph/model-node';
 
 // Geometries
-export {default as Geometry} from './geometry/geometry';
+export type {GeometryProps} from './geometry/geometry';
+export {Geometry} from './geometry/geometry';
+export type {GPUGeometryProps} from './geometry/gpu-geometry';
+export {GPUGeometry} from './geometry/gpu-geometry';
 
 // Primitives
 export type {ConeGeometryProps} from './geometries/cone-geometry';
@@ -34,3 +55,6 @@ export {SphereGeometry} from './geometries/sphere-geometry';
 export type {TruncatedConeGeometryProps} from './geometries/truncated-cone-geometry';
 export {TruncatedConeGeometry} from './geometries/truncated-cone-geometry';
 
+// EXPERIMENTAL
+export type {ShaderModuleInputs} from './shader-inputs';
+export {ShaderInputs as _ShaderInputs} from './shader-inputs';

package/src/lib/clip-space.ts

@@ -1,18 +1,17 @@
 
 // ClipSpace
-/*
-import GL from '@luma.gl/constants';
-import Model, {ModelProps} from './model';
-import Geometry from '../geometry/geometry';
+import {Device, glsl} from '@luma.gl/core';
+import {Model, ModelProps} from '../model/model';
+import {Geometry} from '../geometry/geometry';
 
-const CLIPSPACE_VERTEX_SHADER = `\
-attribute vec2 aClipSpacePosition;
-attribute vec2 aTexCoord;
-attribute vec2 aCoordinate;
+const CLIPSPACE_VERTEX_SHADER = glsl`\
+in vec2 aClipSpacePosition;
+in vec2 aTexCoord;
+in vec2 aCoordinate;
 
-varying vec2 position;
-varying vec2 coordinate;
-varying vec2 uv;
+out vec2 position;
+out vec2 coordinate;
+out vec2 uv;
 
 void main(void) {
   gl_Position = vec4(aClipSpacePosition, 0., 1.);
@@ -22,20 +21,24 @@ void main(void) {
 }
 `;
 
-/* eslint-disable indent, no-multi-spaces *
+/* eslint-disable indent, no-multi-spaces */
 const POSITIONS = [-1, -1, 1, -1, -1, 1, 1, 1];
 
-
-export default class ClipSpace extends Model {
-  constructor(gl: WebGLRenderingContext, opts?: ModelProps) {
+/**
+ * A flat geometry that covers the "visible area" that the GPU renders.
+ */
+export class ClipSpace extends Model {
+  constructor(device: Device, opts?: ModelProps) {
     const TEX_COORDS = POSITIONS.map((coord) => (coord === -1 ? 0 : coord));
 
     super(
-      gl,
-      Object.assign({}, opts, {
+      device,
+      {
+        ...opts,
         vs: CLIPSPACE_VERTEX_SHADER,
+        vertexCount: 4,
         geometry: new Geometry({
-          drawMode: GL.TRIANGLE_STRIP,
+          topology: 'triangle-strip',
           vertexCount: 4,
           attributes: {
             aClipSpacePosition: {size: 2, value: new Float32Array(POSITIONS)},
@@ -43,9 +46,7 @@ export default class ClipSpace extends Model {
             aCoordinate: {size: 2, value: new Float32Array(TEX_COORDS)}
           }
         })
-      })
+      }
     );
-    this.setVertexCount(4);
   }
 }
-*/