@luma.gl/engine 9.0.0-alpha.9 → 9.0.0-beta.10

package/dist/geometry/geometry.js

@@ -1,145 +1,88 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { uid, assert } from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-export default class Geometry {
-  constructor(props = {}) {
-    _defineProperty(this, "id", void 0);
-
-    _defineProperty(this, "userData", {});
-
-    _defineProperty(this, "topology", void 0);
-
-    _defineProperty(this, "drawMode", GL.TRIANGLES);
-
-    _defineProperty(this, "vertexCount", void 0);
-
-    _defineProperty(this, "attributes", void 0);
-
-    _defineProperty(this, "indices", void 0);
-
-    const {
-      id = uid('geometry'),
-      drawMode = GL.TRIANGLES,
-      attributes = {},
-      indices = null,
-      vertexCount = null
-    } = props;
-    this.id = id;
-    this.drawMode = drawMode;
-    this.topology = props.topology || convertToTopology(drawMode);
-
-    if (indices) {
-      this.indices = ArrayBuffer.isView(indices) ? {
-        value: indices,
-        size: 1
-      } : indices;
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { uid, assert } from '@luma.gl/core';
+export class Geometry {
+    id;
+    /** Determines how vertices are read from the 'vertex' attributes */
+    topology;
+    vertexCount;
+    indices;
+    attributes;
+    userData = {};
+    constructor(props) {
+        const { attributes = {}, indices = null, vertexCount = null } = props;
+        this.id = props.id || uid('geometry');
+        this.topology = props.topology;
+        if (indices) {
+            this.indices = ArrayBuffer.isView(indices) ? { value: indices, size: 1 } : indices;
+        }
+        // @ts-expect-error
+        this.attributes = {};
+        for (const [attributeName, attributeValue] of Object.entries(attributes)) {
+            // Wrap "unwrapped" arrays and try to autodetect their type
+            const attribute = ArrayBuffer.isView(attributeValue)
+                ? { value: attributeValue }
+                : attributeValue;
+            assert(ArrayBuffer.isView(attribute.value), `${this._print(attributeName)}: must be typed array or object with value as typed array`);
+            if ((attributeName === 'POSITION' || attributeName === 'positions') && !attribute.size) {
+                attribute.size = 3;
+            }
+            // Move indices to separate field
+            if (attributeName === 'indices') {
+                assert(!this.indices);
+                this.indices = attribute;
+            }
+            else {
+                this.attributes[attributeName] = attribute;
+            }
+        }
+        if (this.indices && this.indices.isIndexed !== undefined) {
+            this.indices = Object.assign({}, this.indices);
+            delete this.indices.isIndexed;
+        }
+        this.vertexCount = vertexCount || this._calculateVertexCount(this.attributes, this.indices);
     }
-
-    this.attributes = {};
-
-    for (const [attributeName, attributeValue] of Object.entries(attributes)) {
-      const attribute = ArrayBuffer.isView(attributeValue) ? {
-        value: attributeValue
-      } : attributeValue;
-      assert(ArrayBuffer.isView(attribute.value), "".concat(this._print(attributeName), ": must be typed array or object with value as typed array"));
-
-      if ((attributeName === 'POSITION' || attributeName === 'positions') && !attribute.size) {
-        attribute.size = 3;
-      }
-
-      if (attributeName === 'indices') {
-        assert(!this.indices);
-        this.indices = attribute;
-      } else {
-        this.attributes[attributeName] = attribute;
-      }
+    getVertexCount() {
+        return this.vertexCount;
     }
-
-    if (this.indices && this.indices.isIndexed !== undefined) {
-      this.indices = Object.assign({}, this.indices);
-      delete this.indices.isIndexed;
+    /**
+     * Return an object with all attributes plus indices added as a field.
+     * TODO Geometry types are a mess
+     */
+    getAttributes() {
+        return this.indices ? { indices: this.indices, ...this.attributes } : this.attributes;
     }
-
-    this.vertexCount = vertexCount || this._calculateVertexCount(this.attributes, this.indices);
-  }
-
-  get mode() {
-    return this.drawMode;
-  }
-
-  getVertexCount() {
-    return this.vertexCount;
-  }
-
-  _print(attributeName) {
-    return "Geometry ".concat(this.id, " attribute ").concat(attributeName);
-  }
-
-  _setAttributes(attributes, indices) {
-    return this;
-  }
-
-  _calculateVertexCount(attributes, indices) {
-    if (indices) {
-      return indices.value.length;
+    // PRIVATE
+    _print(attributeName) {
+        return `Geometry ${this.id} attribute ${attributeName}`;
     }
-
-    let vertexCount = Infinity;
-
-    for (const attributeName in attributes) {
-      const attribute = attributes[attributeName];
-      const {
-        value,
-        size,
-        constant
-      } = attribute;
-
-      if (!constant && value && size >= 1) {
-        vertexCount = Math.min(vertexCount, value.length / size);
-      }
+    /**
+     * 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, indices) {
+        return this;
+    }
+    _calculateVertexCount(attributes, indices) {
+        if (indices) {
+            return indices.value.length;
+        }
+        let vertexCount = Infinity;
+        for (const attribute of Object.values(attributes)) {
+            const { value, size, constant } = attribute;
+            if (!constant && value && size >= 1) {
+                vertexCount = Math.min(vertexCount, value.length / size);
+            }
+        }
+        assert(Number.isFinite(vertexCount));
+        return vertexCount;
     }
-
-    assert(Number.isFinite(vertexCount));
-    return vertexCount;
-  }
-
-}
-
-_defineProperty(Geometry, "DRAW_MODE", {
-  POINTS: GL.POINTS,
-  LINES: GL.LINES,
-  LINE_LOOP: GL.LINE_LOOP,
-  LINE_STRIP: GL.LINE_STRIP,
-  TRIANGLES: GL.TRIANGLES,
-  TRIANGLE_STRIP: GL.TRIANGLE_STRIP,
-  TRIANGLE_FAN: GL.TRIANGLE_FAN
-});
-
-function convertToTopology(drawMode) {
-  switch (drawMode) {
-    case GL.POINTS:
-      return 'point-list';
-
-    case GL.LINES:
-      return 'line-list';
-
-    case GL.LINE_STRIP:
-      return 'line-strip';
-
-    case GL.TRIANGLES:
-      return 'triangle-list';
-
-    case GL.TRIANGLE_STRIP:
-      return 'triangle-strip';
-
-    case GL.TRIANGLE_FAN:
-      return 'triangle-fan';
-
-    case GL.LINE_LOOP:
-      return 'line-loop';
-
-    default:
-      throw new Error(String(drawMode));
-  }
 }
-//# sourceMappingURL=geometry.js.map

package/dist/geometry/gpu-geometry.d.ts

@@ -0,0 +1,37 @@
+import type { PrimitiveTopology, BufferLayout } from '@luma.gl/core';
+import { Device, Buffer } from '@luma.gl/core';
+import type { Geometry } from "../geometry/geometry.js";
+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 declare 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);
+    destroy(): void;
+    getVertexCount(): number;
+    getAttributes(): Record<string, Buffer>;
+    getIndexes(): Buffer | null;
+    _calculateVertexCount(positions: Buffer): number;
+}
+export declare function makeGPUGeometry(device: Device, geometry: Geometry | GPUGeometry): GPUGeometry;
+export declare function getIndexBufferFromGeometry(device: Device, geometry: Geometry): Buffer | undefined;
+export declare function getAttributeBuffersFromGeometry(device: Device, geometry: Geometry): {
+    attributes: Record<string, Buffer>;
+    bufferLayout: BufferLayout[];
+    vertexCount: number;
+};
+//# sourceMappingURL=gpu-geometry.d.ts.map

package/dist/geometry/gpu-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-geometry.d.ts","sourceRoot":"","sources":["../../src/geometry/gpu-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,iBAAiB,EAAE,YAAY,EAAC,MAAM,eAAe,CAAC;AACnE,OAAO,EAAC,MAAM,EAAE,MAAM,EAA4C,MAAM,eAAe,CAAC;AACxF,OAAO,KAAK,EAAC,QAAQ,EAAC,gCAA6B;AAEnD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,oEAAoE;IACpE,QAAQ,EACJ,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,iBAAiB,GACjB,eAAe,GACf,gBAAgB,GAChB,oBAAoB,CAAC;IACzB,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,YAAY,EAAE,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC,CAAC;AAEF,qBAAa,WAAW;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM;IAEvC,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IACtC,QAAQ,CAAC,YAAY,EAAE,YAAY,EAAE,CAAM;IAE3C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAEhC,KAAK,EAAE,gBAAgB;IAenC,OAAO,IAAI,IAAI;IAOf,cAAc,IAAI,MAAM;IAIxB,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAIvC,UAAU,IAAI,MAAM,GAAG,IAAI;IAI3B,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAKjD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,WAAW,GAAG,WAAW,CAc7F;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAMjG;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,GACjB;IAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,YAAY,EAAE,YAAY,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CA6BzF"}

package/dist/geometry/gpu-geometry.js

@@ -0,0 +1,90 @@
+import { Buffer, uid, assert, getVertexFormatFromAttribute } from '@luma.gl/core';
+export class GPUGeometry {
+    id;
+    userData = {};
+    /** Determines how vertices are read from the 'vertex' attributes */
+    topology;
+    bufferLayout = [];
+    vertexCount;
+    indices;
+    attributes;
+    constructor(props) {
+        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() {
+        this.indices?.destroy();
+        for (const attribute of Object.values(this.attributes)) {
+            attribute.destroy();
+        }
+    }
+    getVertexCount() {
+        return this.vertexCount;
+    }
+    getAttributes() {
+        return this.attributes;
+    }
+    getIndexes() {
+        return this.indices;
+    }
+    _calculateVertexCount(positions) {
+        // Assume that positions is a fully packed float32x3 buffer
+        const vertexCount = positions.byteLength / 12;
+        return vertexCount;
+    }
+}
+export function makeGPUGeometry(device, geometry) {
+    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, geometry) {
+    if (!geometry.indices) {
+        return undefined;
+    }
+    const data = geometry.indices.value;
+    return device.createBuffer({ usage: Buffer.INDEX, data });
+}
+export function getAttributeBuffersFromGeometry(device, geometry) {
+    const bufferLayout = [];
+    const attributes = {};
+    for (const [attributeName, attribute] of Object.entries(geometry.attributes)) {
+        let name = 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/dist/geometry/gpu-table.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=gpu-table.d.ts.map

package/dist/geometry/gpu-table.d.ts.map

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

package/dist/geometry/gpu-table.js

@@ -0,0 +1,42 @@
+"use strict";
+/*
+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();
+}
+*/